diff --git a/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/config/CqlDstu3Config.java b/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/config/CqlDstu3Config.java index 72d72c9a245..d624d797628 100644 --- a/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/config/CqlDstu3Config.java +++ b/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/config/CqlDstu3Config.java @@ -30,7 +30,6 @@ import ca.uhn.fhir.cql.dstu3.provider.JpaTerminologyProvider; import ca.uhn.fhir.cql.dstu3.provider.LibraryResolutionProviderImpl; import ca.uhn.fhir.cql.dstu3.provider.MeasureOperationsProvider; import ca.uhn.fhir.jpa.api.dao.DaoRegistry; -import ca.uhn.fhir.jpa.rp.dstu3.ValueSetResourceProvider; import ca.uhn.fhir.jpa.term.api.ITermReadSvcDstu3; import org.opencds.cqf.cql.engine.model.ModelResolver; @@ -39,6 +38,7 @@ import java.util.Map; import org.cqframework.cql.cql2elm.model.Model; import org.hl7.elm.r1.VersionedIdentifier; +import org.hl7.fhir.dstu3.model.ValueSet; import org.opencds.cqf.cql.engine.fhir.model.Dstu3FhirModelResolver; import org.opencds.cqf.cql.engine.terminology.TerminologyProvider; import org.opencds.cqf.cql.evaluator.engine.model.CachingModelResolverDecorator; @@ -50,14 +50,16 @@ import org.springframework.context.annotation.Lazy; public class CqlDstu3Config extends BaseCqlConfig { @Lazy @Bean - TerminologyProvider terminologyProvider(ITermReadSvcDstu3 theITermReadSvc, - ValueSetResourceProvider theValueSetResourceProvider, IValidationSupport theValidationSupport) { - return new JpaTerminologyProvider(theITermReadSvc, theValueSetResourceProvider, theValidationSupport); + TerminologyProvider terminologyProvider(ITermReadSvcDstu3 theITermReadSvc, DaoRegistry daoRegistry, + IValidationSupport theValidationSupport) { + return new JpaTerminologyProvider(theITermReadSvc, daoRegistry.getResourceDao(ValueSet.class), + theValidationSupport); } @Lazy @Bean - EvaluationProviderFactory evaluationProviderFactory(FhirContext theFhirContext, DaoRegistry theDaoRegistry, TerminologyProvider theLocalSystemTerminologyProvider, ModelResolver modelResolver) { + EvaluationProviderFactory evaluationProviderFactory(FhirContext theFhirContext, DaoRegistry theDaoRegistry, + TerminologyProvider theLocalSystemTerminologyProvider, ModelResolver modelResolver) { return new ProviderFactory(theFhirContext, theDaoRegistry, theLocalSystemTerminologyProvider, modelResolver); } @@ -66,7 +68,7 @@ public class CqlDstu3Config extends BaseCqlConfig { LibraryResolutionProvider libraryResolutionProvider() { return new LibraryResolutionProviderImpl(); } - + @Lazy @Bean public MeasureOperationsProvider measureOperationsProvider() { @@ -74,7 +76,7 @@ public class CqlDstu3Config extends BaseCqlConfig { } @Bean - public ModelResolver fhirModelResolver () { + public ModelResolver fhirModelResolver() { return new CachingModelResolverDecorator(new Dstu3FhirModelResolver()); } diff --git a/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/config/CqlR4Config.java b/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/config/CqlR4Config.java index 90b92901242..ea62e5e0f0d 100644 --- a/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/config/CqlR4Config.java +++ b/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/config/CqlR4Config.java @@ -31,7 +31,6 @@ import ca.uhn.fhir.cql.r4.helper.LibraryHelper; import ca.uhn.fhir.cql.r4.provider.JpaTerminologyProvider; import ca.uhn.fhir.cql.r4.provider.MeasureOperationsProvider; import ca.uhn.fhir.jpa.api.dao.DaoRegistry; -import ca.uhn.fhir.jpa.rp.r4.ValueSetResourceProvider; import ca.uhn.fhir.jpa.term.api.ITermReadSvcR4; import org.opencds.cqf.cql.engine.model.ModelResolver; @@ -40,6 +39,7 @@ import java.util.Map; import org.cqframework.cql.cql2elm.model.Model; import org.hl7.elm.r1.VersionedIdentifier; +import org.hl7.fhir.r4.model.ValueSet; import org.opencds.cqf.cql.engine.fhir.model.R4FhirModelResolver; import org.opencds.cqf.cql.engine.terminology.TerminologyProvider; import org.opencds.cqf.cql.evaluator.engine.model.CachingModelResolverDecorator; @@ -58,13 +58,15 @@ public class CqlR4Config extends BaseCqlConfig { @Lazy @Bean - TerminologyProvider terminologyProvider(ITermReadSvcR4 theITermReadSvc, ValueSetResourceProvider theValueSetResourceProvider, IValidationSupport theValidationSupport) { - return new JpaTerminologyProvider(theITermReadSvc,theValueSetResourceProvider, theValidationSupport); + TerminologyProvider terminologyProvider(ITermReadSvcR4 theITermReadSvc, DaoRegistry daoRegistry, + IValidationSupport theValidationSupport) { + return new JpaTerminologyProvider(theITermReadSvc, daoRegistry.getResourceDao(ValueSet.class), theValidationSupport); } @Lazy @Bean - EvaluationProviderFactory evaluationProviderFactory(FhirContext theFhirContext, DaoRegistry theDaoRegistry, TerminologyProvider theLocalSystemTerminologyProvider, ModelResolver modelResolver) { + EvaluationProviderFactory evaluationProviderFactory(FhirContext theFhirContext, DaoRegistry theDaoRegistry, + TerminologyProvider theLocalSystemTerminologyProvider, ModelResolver modelResolver) { return new ProviderFactory(theFhirContext, theDaoRegistry, theLocalSystemTerminologyProvider, modelResolver); } @@ -81,7 +83,7 @@ public class CqlR4Config extends BaseCqlConfig { } @Bean - public ModelResolver fhirModelResolver () { + public ModelResolver fhirModelResolver() { return new CachingModelResolverDecorator(new R4FhirModelResolver()); } diff --git a/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/dstu3/provider/JpaTerminologyProvider.java b/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/dstu3/provider/JpaTerminologyProvider.java index 0fa812a153b..0512f5ea6a1 100644 --- a/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/dstu3/provider/JpaTerminologyProvider.java +++ b/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/dstu3/provider/JpaTerminologyProvider.java @@ -20,12 +20,10 @@ package ca.uhn.fhir.cql.dstu3.provider; * #L% */ -import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.context.support.IValidationSupport; import ca.uhn.fhir.context.support.IValidationSupport.LookupCodeResult; import ca.uhn.fhir.context.support.ValidationSupportContext; import ca.uhn.fhir.context.support.ValueSetExpansionOptions; -import ca.uhn.fhir.jpa.rp.dstu3.ValueSetResourceProvider; import ca.uhn.fhir.jpa.api.dao.IFhirResourceDao; import ca.uhn.fhir.jpa.searchparam.SearchParameterMap; import ca.uhn.fhir.jpa.term.api.ITermReadSvcDstu3; @@ -34,7 +32,6 @@ import ca.uhn.fhir.rest.param.UriParam; import ca.uhn.fhir.rest.server.exceptions.ResourceNotFoundException; import org.hl7.fhir.dstu3.model.IdType; import org.hl7.fhir.dstu3.model.ValueSet; -import org.hl7.fhir.dstu3.model.ValueSet.ValueSetExpansionContainsComponent; import org.hl7.fhir.instance.model.api.IBaseResource; import org.opencds.cqf.cql.engine.runtime.Code; import org.opencds.cqf.cql.engine.terminology.CodeSystemInfo; @@ -53,14 +50,14 @@ import java.util.List; public class JpaTerminologyProvider implements TerminologyProvider { private ITermReadSvcDstu3 terminologySvc; - private ValueSetResourceProvider valueSetResourceProvider; + private IFhirResourceDao valueSetDao; private final IValidationSupport validationSupport; @Autowired public JpaTerminologyProvider(ITermReadSvcDstu3 terminologySvc, - ValueSetResourceProvider valueSetResourceProvider, IValidationSupport validationSupport) { + IFhirResourceDao valueSetDao, IValidationSupport validationSupport) { this.terminologySvc = terminologySvc; - this.valueSetResourceProvider = valueSetResourceProvider; + this.valueSetDao = valueSetDao; this.validationSupport = validationSupport; } @@ -78,9 +75,8 @@ public class JpaTerminologyProvider implements TerminologyProvider { @Override public Iterable expand(ValueSetInfo valueSet) throws ResourceNotFoundException { - List codes = new ArrayList<>(); - boolean needsExpand = false; - ValueSet vs = null; + // This could possibly be refactored into a single call to the underlying HAPI Terminology service. Need to think through that.., + ValueSet vs; if (valueSet.getId().startsWith("http://") || valueSet.getId().startsWith("https://")) { if (valueSet.getVersion() != null || (valueSet.getCodeSystems() != null && valueSet.getCodeSystems().size() > 0)) { @@ -90,7 +86,8 @@ public class JpaTerminologyProvider implements TerminologyProvider { valueSet.getId())); } } - IBundleProvider bundleProvider = valueSetResourceProvider.getDao() + + IBundleProvider bundleProvider = this.valueSetDao .search(new SearchParameterMap().add(ValueSet.SP_URL, new UriParam(valueSet.getId()))); List valueSets = bundleProvider.getResources(0, bundleProvider.size()); if (valueSets.isEmpty()) { @@ -101,41 +98,37 @@ public class JpaTerminologyProvider implements TerminologyProvider { throw new IllegalArgumentException("Found more than 1 ValueSet with url: " + valueSet.getId()); } } else { - vs = valueSetResourceProvider.getDao().read(new IdType(valueSet.getId())); - } - if (vs != null) { - if (vs.hasCompose()) { - if (vs.getCompose().hasInclude()) { - for (ValueSet.ConceptSetComponent include : vs.getCompose().getInclude()) { - if (include.hasValueSet() || include.hasFilter()) { - needsExpand = true; - break; - } - for (ValueSet.ConceptReferenceComponent concept : include.getConcept()) { - if (concept.hasCode()) { - codes.add(new Code().withCode(concept.getCode()).withSystem(include.getSystem())); - } - } - } - if (!needsExpand) { - return codes; - } - } - } - - if (vs.hasExpansion() && vs.getExpansion().hasContains()) { - for (ValueSetExpansionContainsComponent vsecc : vs.getExpansion().getContains()) { - codes.add(new Code().withCode(vsecc.getCode()).withSystem(vsecc.getSystem())); - } - - return codes; + vs = this.valueSetDao.read(new IdType(valueSet.getId())); + if (vs == null) { + throw new IllegalArgumentException(String.format("Could not resolve value set %s.", valueSet.getId())); } } - org.hl7.fhir.r4.model.ValueSet expansion = terminologySvc - .expandValueSet(new ValueSetExpansionOptions().setCount(Integer.MAX_VALUE), valueSet.getId(), null); - expansion.getExpansion().getContains() - .forEach(concept -> codes.add(new Code().withCode(concept.getCode()).withSystem(concept.getSystem()))); + // Attempt to expand the ValueSet if it's not already expanded. + if (!(vs.hasExpansion() && vs.getExpansion().hasContains())) { + vs = (ValueSet)this.terminologySvc.expandValueSet( + new ValueSetExpansionOptions().setCount(Integer.MAX_VALUE).setFailOnMissingCodeSystem(false), vs); + } + + List codes = new ArrayList<>(); + + // If expansion was successful, use the codes. + if (vs.hasExpansion() && vs.getExpansion().hasContains()) { + for (ValueSet.ValueSetExpansionContainsComponent vsecc : vs.getExpansion().getContains()) { + codes.add(new Code().withCode(vsecc.getCode()).withSystem(vsecc.getSystem())); + } + } + // If not, best-effort based on codes. Should probably make this configurable to match the behavior of the + // underlying terminology service implementation + else if (vs.hasCompose() && vs.getCompose().hasInclude()) { + for (ValueSet.ConceptSetComponent include : vs.getCompose().getInclude()) { + for (ValueSet.ConceptReferenceComponent concept : include.getConcept()) { + if (concept.hasCode()) { + codes.add(new Code().withCode(concept.getCode()).withSystem(include.getSystem())); + } + } + } + } return codes; } diff --git a/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/r4/provider/JpaTerminologyProvider.java b/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/r4/provider/JpaTerminologyProvider.java index 0a67792daa9..57059c2e32e 100644 --- a/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/r4/provider/JpaTerminologyProvider.java +++ b/hapi-fhir-jpaserver-cql/src/main/java/ca/uhn/fhir/cql/r4/provider/JpaTerminologyProvider.java @@ -20,12 +20,11 @@ package ca.uhn.fhir.cql.r4.provider; * #L% */ -import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.context.support.IValidationSupport; import ca.uhn.fhir.context.support.IValidationSupport.LookupCodeResult; import ca.uhn.fhir.context.support.ValidationSupportContext; import ca.uhn.fhir.context.support.ValueSetExpansionOptions; -import ca.uhn.fhir.jpa.rp.r4.ValueSetResourceProvider; +import ca.uhn.fhir.jpa.api.dao.IFhirResourceDao; import ca.uhn.fhir.jpa.searchparam.SearchParameterMap; import ca.uhn.fhir.jpa.term.api.ITermReadSvcR4; import ca.uhn.fhir.rest.api.server.IBundleProvider; @@ -48,102 +47,98 @@ import java.util.List; @Component public class JpaTerminologyProvider implements TerminologyProvider { - private ITermReadSvcR4 terminologySvc; - private ValueSetResourceProvider valueSetResourceProvider; - private final IValidationSupport validationSupport; + private ITermReadSvcR4 terminologySvc; + private IFhirResourceDao valueSetDao; + private final IValidationSupport validationSupport; - @Autowired - public JpaTerminologyProvider(ITermReadSvcR4 terminologySvc, - ValueSetResourceProvider valueSetResourceProvider, IValidationSupport validationSupport) { - this.terminologySvc = terminologySvc; - this.valueSetResourceProvider = valueSetResourceProvider; - this.validationSupport = validationSupport; - } + @Autowired + public JpaTerminologyProvider(ITermReadSvcR4 terminologySvc, IFhirResourceDao valueSetDao, + IValidationSupport validationSupport) { + this.terminologySvc = terminologySvc; + this.valueSetDao = valueSetDao; + this.validationSupport = validationSupport; + } - @Override - public boolean in(Code code, ValueSetInfo valueSet) throws ResourceNotFoundException { - for (Code c : expand(valueSet)) { - if (c == null) - continue; - if (c.getCode().equals(code.getCode()) && c.getSystem().equals(code.getSystem())) { - return true; - } - } - return false; - } + @Override + public boolean in(Code code, ValueSetInfo valueSet) throws ResourceNotFoundException { + for (Code c : expand(valueSet)) { + if (c == null) + continue; + if (c.getCode().equals(code.getCode()) && c.getSystem().equals(code.getSystem())) { + return true; + } + } + return false; + } - @Override - public Iterable expand(ValueSetInfo valueSet) throws ResourceNotFoundException { - List codes = new ArrayList<>(); - boolean needsExpand = false; - ValueSet vs; - if (valueSet.getId().startsWith("http://") || valueSet.getId().startsWith("https://")) { - if (valueSet.getVersion() != null - || (valueSet.getCodeSystems() != null && valueSet.getCodeSystems().size() > 0)) { - if (!(valueSet.getCodeSystems().size() == 1 && valueSet.getCodeSystems().get(0).getVersion() == null)) { - throw new UnsupportedOperationException(String.format( - "Could not expand value set %s; version and code system bindings are not supported at this time.", - valueSet.getId())); - } - } - IBundleProvider bundleProvider = valueSetResourceProvider.getDao() - .search(new SearchParameterMap().add(ValueSet.SP_URL, new UriParam(valueSet.getId()))); - List valueSets = bundleProvider.getResources(0, bundleProvider.size()); - if (valueSets.isEmpty()) { - throw new IllegalArgumentException(String.format("Could not resolve value set %s.", valueSet.getId())); - } else if (valueSets.size() == 1) { - vs = (ValueSet) valueSets.get(0); - } else { - throw new IllegalArgumentException("Found more than 1 ValueSet with url: " + valueSet.getId()); - } - } else { - vs = valueSetResourceProvider.getDao().read(new IdType(valueSet.getId())); - } - if (vs != null) { - if (vs.hasCompose()) { - if (vs.getCompose().hasInclude()) { - for (ValueSet.ConceptSetComponent include : vs.getCompose().getInclude()) { - if (include.hasValueSet() || include.hasFilter()) { - needsExpand = true; - break; - } - for (ValueSet.ConceptReferenceComponent concept : include.getConcept()) { - if (concept.hasCode()) { - codes.add(new Code().withCode(concept.getCode()).withSystem(include.getSystem())); - } - } - } - if (!needsExpand) { - return codes; - } - } - } + @Override + public Iterable expand(ValueSetInfo valueSet) throws ResourceNotFoundException { + // This could possibly be refactored into a single call to the underlying HAPI Terminology service. Need to think through that.., + ValueSet vs; + if (valueSet.getId().startsWith("http://") || valueSet.getId().startsWith("https://")) { + if (valueSet.getVersion() != null + || (valueSet.getCodeSystems() != null && valueSet.getCodeSystems().size() > 0)) { + if (!(valueSet.getCodeSystems().size() == 1 && valueSet.getCodeSystems().get(0).getVersion() == null)) { + throw new UnsupportedOperationException(String.format( + "Could not expand value set %s; version and code system bindings are not supported at this time.", + valueSet.getId())); + } + } - if (vs.hasExpansion() && vs.getExpansion().hasContains()) { - for (ValueSetExpansionContainsComponent vsecc : vs.getExpansion().getContains()) { - codes.add(new Code().withCode(vsecc.getCode()).withSystem(vsecc.getSystem())); - } + IBundleProvider bundleProvider = this.valueSetDao + .search(new SearchParameterMap().add(ValueSet.SP_URL, new UriParam(valueSet.getId()))); + List valueSets = bundleProvider.getResources(0, bundleProvider.size()); + if (valueSets.isEmpty()) { + throw new IllegalArgumentException(String.format("Could not resolve value set %s.", valueSet.getId())); + } else if (valueSets.size() == 1) { + vs = (ValueSet) valueSets.get(0); + } else { + throw new IllegalArgumentException("Found more than 1 ValueSet with url: " + valueSet.getId()); + } + } else { + vs = this.valueSetDao.read(new IdType(valueSet.getId())); + if (vs == null) { + throw new IllegalArgumentException(String.format("Could not resolve value set %s.", valueSet.getId())); + } + } - return codes; - } + // Attempt to expand the ValueSet if it's not already expanded. + if (!(vs.hasExpansion() && vs.getExpansion().hasContains())) { + vs = (ValueSet)this.terminologySvc.expandValueSet( + new ValueSetExpansionOptions().setCount(Integer.MAX_VALUE).setFailOnMissingCodeSystem(false), vs); + } - } + List codes = new ArrayList<>(); - ValueSet expansion = terminologySvc - .expandValueSet(new ValueSetExpansionOptions().setCount(Integer.MAX_VALUE), valueSet.getId(), null); - expansion.getExpansion().getContains() - .forEach(concept -> codes.add(new Code().withCode(concept.getCode()).withSystem(concept.getSystem()))); + // If expansion was successful, use the codes. + if (vs.hasExpansion() && vs.getExpansion().hasContains()) { + for (ValueSetExpansionContainsComponent vsecc : vs.getExpansion().getContains()) { + codes.add(new Code().withCode(vsecc.getCode()).withSystem(vsecc.getSystem())); + } + } + // If not, best-effort based on codes. Should probably make this configurable to match the behavior of the + // underlying terminology service implementation + else if (vs.hasCompose() && vs.getCompose().hasInclude()) { + for (ValueSet.ConceptSetComponent include : vs.getCompose().getInclude()) { + for (ValueSet.ConceptReferenceComponent concept : include.getConcept()) { + if (concept.hasCode()) { + codes.add(new Code().withCode(concept.getCode()).withSystem(include.getSystem())); + } + } + } + } - return codes; - } + return codes; + } - @Override - public Code lookup(Code code, CodeSystemInfo codeSystem) throws ResourceNotFoundException { - LookupCodeResult cs = terminologySvc.lookupCode(new ValidationSupportContext(validationSupport), codeSystem.getId(), code.getCode()); + @Override + public Code lookup(Code code, CodeSystemInfo codeSystem) throws ResourceNotFoundException { + LookupCodeResult cs = terminologySvc.lookupCode(new ValidationSupportContext(validationSupport), + codeSystem.getId(), code.getCode()); - code.setDisplay(cs.getCodeDisplay()); - code.setSystem(codeSystem.getId()); + code.setDisplay(cs.getCodeDisplay()); + code.setSystem(codeSystem.getId()); - return code; - } + return code; + } } diff --git a/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/config/TestCqlConfig.java b/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/config/TestCqlConfig.java index 3bcc29d2caa..3de66069509 100644 --- a/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/config/TestCqlConfig.java +++ b/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/config/TestCqlConfig.java @@ -4,6 +4,10 @@ import ca.uhn.fhir.jpa.subscription.channel.config.SubscriptionChannelConfig; import ca.uhn.fhir.jpa.subscription.submit.config.SubscriptionSubmitterConfig; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Primary; + + @Configuration @Import({SubscriptionSubmitterConfig.class, SubscriptionChannelConfig.class}) diff --git a/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/dstu3/provider/JpaTerminologyProviderTest.java b/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/dstu3/provider/JpaTerminologyProviderTest.java new file mode 100644 index 00000000000..10f8d7c1d84 --- /dev/null +++ b/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/dstu3/provider/JpaTerminologyProviderTest.java @@ -0,0 +1,51 @@ +package ca.uhn.fhir.cql.dstu3.provider; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.opencds.cqf.cql.engine.runtime.Code; +import org.opencds.cqf.cql.engine.terminology.TerminologyProvider; +import org.opencds.cqf.cql.engine.terminology.ValueSetInfo; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; + +import ca.uhn.fhir.cql.BaseCqlDstu3Test; +import ca.uhn.fhir.jpa.api.config.DaoConfig; + +public class JpaTerminologyProviderTest extends BaseCqlDstu3Test { + private static final Logger ourLog = LoggerFactory.getLogger(JpaTerminologyProviderTest.class); + + @Autowired + protected TerminologyProvider jpaTerminologyProvider; + + @Autowired + protected DaoConfig daoConfig; + + @BeforeEach + public void before() throws IOException { + // Load executable (i.e. "pre-expanded") value set + loadResource("dstu3/provider/test-executable-value-set.json"); + } + + @Test + public void testTerminologyProviderExpand() { + ValueSetInfo valueSetInfo = new ValueSetInfo().withId("http://test.com/fhir/ValueSet/test-executable-value-set"); + Iterable codeIterable = this.jpaTerminologyProvider.expand(valueSetInfo); + + assertNotNull(codeIterable); + + List codes = new ArrayList<>(); + + codeIterable.forEach(codes::add); + + assertThat(codes, hasSize(2)); + } +} diff --git a/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/r4/CqlMeasureEvaluationR4Test.java b/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/r4/CqlMeasureEvaluationR4Test.java new file mode 100644 index 00000000000..93cd00b4a76 --- /dev/null +++ b/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/r4/CqlMeasureEvaluationR4Test.java @@ -0,0 +1,54 @@ +package ca.uhn.fhir.cql.r4; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.io.IOException; +import java.math.BigDecimal; + +import org.hl7.fhir.r4.model.IdType; +import org.hl7.fhir.r4.model.MeasureReport; +import org.hl7.fhir.r4.model.Quantity; +import org.hl7.fhir.r4.model.MeasureReport.MeasureReportGroupPopulationComponent; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +import ca.uhn.fhir.cql.BaseCqlR4Test; +import ca.uhn.fhir.cql.common.provider.CqlProviderTestBase; +import ca.uhn.fhir.cql.r4.provider.MeasureOperationsProvider; + +public class CqlMeasureEvaluationR4Test extends BaseCqlR4Test implements CqlProviderTestBase { + + private static final IdType measureId = new IdType("Measure", "measure-EXM130-7.3.000"); + private static final String periodStart = "2019-01-01"; + private static final String periodEnd = "2019-12-31"; + + @Autowired + MeasureOperationsProvider myMeasureOperationsProvider; + + public void loadBundles() throws IOException { + loadBundle("r4/connectathon/EXM130-7.3.000-bundle.json"); + } + + @Test + public void testExm130PatientNumerator() throws IOException { + loadBundles(); + MeasureReport report = myMeasureOperationsProvider.evaluateMeasure(measureId, periodStart, periodEnd, null, "patient", + "numer-EXM130", null, null, null, null, null, null); + // Assert it worked + assertThat(report.getGroup(), hasSize(1)); + assertEquals(new BigDecimal("1.0"), report.getGroupFirstRep().getMeasureScore().getValue()); + } + + @Test + public void testExm130PatientDenominator() throws IOException { + loadBundles(); + MeasureReport report = myMeasureOperationsProvider.evaluateMeasure(measureId, periodStart, periodEnd, null, "patient", + "denom-EXM130", null, null, null, null, null, null); + // Assert it worked + assertThat(report.getGroup(), hasSize(1)); + assertEquals(new BigDecimal("0.0"), report.getGroupFirstRep().getMeasureScore().getValue()); + } +} diff --git a/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/r4/provider/JpaTerminologyProviderTest.java b/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/r4/provider/JpaTerminologyProviderTest.java new file mode 100644 index 00000000000..b2e63da8ada --- /dev/null +++ b/hapi-fhir-jpaserver-cql/src/test/java/ca/uhn/fhir/cql/r4/provider/JpaTerminologyProviderTest.java @@ -0,0 +1,51 @@ +package ca.uhn.fhir.cql.r4.provider; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.opencds.cqf.cql.engine.runtime.Code; +import org.opencds.cqf.cql.engine.terminology.TerminologyProvider; +import org.opencds.cqf.cql.engine.terminology.ValueSetInfo; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; + +import ca.uhn.fhir.cql.BaseCqlR4Test; +import ca.uhn.fhir.jpa.api.config.DaoConfig; + +public class JpaTerminologyProviderTest extends BaseCqlR4Test { + private static final Logger ourLog = LoggerFactory.getLogger(JpaTerminologyProviderTest.class); + + @Autowired + protected TerminologyProvider jpaTerminologyProvider; + + @Autowired + protected DaoConfig daoConfig; + + @BeforeEach + public void before() throws IOException { + // Load executable (i.e. "pre-expanded") value set + loadResource("r4/provider/test-executable-value-set.json"); + } + + @Test + public void testTerminologyProviderExpand() { + ValueSetInfo valueSetInfo = new ValueSetInfo().withId("http://test.com/fhir/ValueSet/test-executable-value-set"); + Iterable codeIterable = this.jpaTerminologyProvider.expand(valueSetInfo); + + assertNotNull(codeIterable); + + List codes = new ArrayList<>(); + + codeIterable.forEach(codes::add); + + assertThat(codes, hasSize(2)); + } +} diff --git a/hapi-fhir-jpaserver-cql/src/test/resources/dstu3/provider/test-executable-value-set.json b/hapi-fhir-jpaserver-cql/src/test/resources/dstu3/provider/test-executable-value-set.json new file mode 100644 index 00000000000..aee3eb2aa2a --- /dev/null +++ b/hapi-fhir-jpaserver-cql/src/test/resources/dstu3/provider/test-executable-value-set.json @@ -0,0 +1,39 @@ +{ + "resourceType": "ValueSet", + "id": "test-executable-value-set", + "meta" : { + "profile" : [ + "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-executablevalueset" + ] + }, + "url": "http://test.com/fhir/ValueSet/test-executable-value-set", + "extension" : [ + { + "url" : "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-knowledgeCapability", + "valueCode" : "executable" + }, + { + "url" : "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-knowledgeRepresentationLevel", + "valueCode" : "executable" + }, + { + "url" : "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-usageWarning", + "valueString" : "This value set contains a point-in-time expansion enumerating the codes that meet the value set intent. As new versions of the code systems used by the value set are released, the contents of this expansion will need to be updated to incorporate newly defined codes that meet the value set intent. Before, and periodically during production use, the value set expansion contents SHOULD be updated. The value set expansion specifies the timestamp when the expansion was produced, SHOULD contain the parameters used for the expansion, and SHALL contain the codes that are obtained by evaluating the value set definition. If this is ONLY an executable value set, a distributable definition of the value set must be obtained to compute the updated expansion." + } + ], + "expansion": { + "timestamp" : "2020-03-26T17:39:09-06:00", + "contains" : [ + { + "system" : "http://test.com/codesystem/test", + "code" : "1234", + "display" : "1234" + }, + { + "system" : "http://test.com/codesystem/test", + "code" : "ABCD", + "display" : "ABCD" + } + ] + } + } diff --git a/hapi-fhir-jpaserver-cql/src/test/resources/r4/connectathon/EXM130-7.3.000-bundle.json b/hapi-fhir-jpaserver-cql/src/test/resources/r4/connectathon/EXM130-7.3.000-bundle.json new file mode 100644 index 00000000000..78a65360c1b --- /dev/null +++ b/hapi-fhir-jpaserver-cql/src/test/resources/r4/connectathon/EXM130-7.3.000-bundle.json @@ -0,0 +1,3495 @@ +{ + "resourceType": "Bundle", + "id": "EXM130-7.3.000-bundle", + "type": "transaction", + "entry": [ { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.114222.4.11.836", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.836", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.114222.4.11.836" + } ], + "version": "20121025", + "name": "Race", + "title": "Race", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.cdc.gov/phin/resources/vocabulary/index.html", + "version": "1.2", + "concept": [ { + "code": "1002-5", + "display": "American Indian or Alaska Native" + }, { + "code": "2028-9", + "display": "Asian" + }, { + "code": "2054-5", + "display": "Black or African American" + }, { + "code": "2076-8", + "display": "Native Hawaiian or Other Pacific Islander" + }, { + "code": "2106-3", + "display": "White" + }, { + "code": "2131-1", + "display": "Other Race" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.114222.4.11.836" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.114222.4.11.837", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.837", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.114222.4.11.837" + } ], + "version": "20121025", + "name": "Ethnicity", + "title": "Ethnicity", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.cdc.gov/phin/resources/vocabulary/index.html", + "version": "1.2", + "concept": [ { + "code": "2135-2", + "display": "Hispanic or Latino" + }, { + "code": "2186-5", + "display": "Not Hispanic or Latino" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.114222.4.11.837" + } + }, { + "resource": { + "resourceType": "Encounter", + "id": "numer-EXM130-4", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" ] + }, + "status": "finished", + "class": { + "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode", + "code": "AMB", + "display": "ambulatory" + }, + "type": [ { + "coding": [ { + "system": "http://www.ama-assn.org/go/cpt", + "code": "99201", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: A problem focused history; A problem focused examination; Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are self limited or minor. Typically, 10 minutes are spent face-to-face with the patient and/or family." + } ] + } ], + "subject": { + "reference": "Patient/numer-EXM130" + }, + "period": { + "start": "2019-05-30T00:00:00.0", + "end": "2019-05-31T00:00:00.0" + } + }, + "request": { + "method": "PUT", + "url": "Encounter/numer-EXM130-4" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.108.12.1001", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1001", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.108.12.1001" + } ], + "version": "20171222", + "name": "MalignantNeoplasmofColon", + "title": "Malignant Neoplasm of Colon", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://hl7.org/fhir/sid/icd-10", + "version": "2019", + "concept": [ { + "code": "C18.0", + "display": "Malignant neoplasm of cecum" + }, { + "code": "C18.1", + "display": "Malignant neoplasm of appendix" + }, { + "code": "C18.2", + "display": "Malignant neoplasm of ascending colon" + }, { + "code": "C18.3", + "display": "Malignant neoplasm of hepatic flexure" + }, { + "code": "C18.4", + "display": "Malignant neoplasm of transverse colon" + }, { + "code": "C18.5", + "display": "Malignant neoplasm of splenic flexure" + }, { + "code": "C18.6", + "display": "Malignant neoplasm of descending colon" + }, { + "code": "C18.7", + "display": "Malignant neoplasm of sigmoid colon" + }, { + "code": "C18.8", + "display": "Malignant neoplasm of overlapping sites of colon" + }, { + "code": "C18.9", + "display": "Malignant neoplasm of colon, unspecified" + }, { + "code": "C19", + "display": "Malignant neoplasm of rectosigmoid junction" + }, { + "code": "C20", + "display": "Malignant neoplasm of rectum" + }, { + "code": "C21.2", + "display": "Malignant neoplasm of cloacogenic zone" + }, { + "code": "C21.8", + "display": "Malignant neoplasm of overlapping sites of rectum, anus and anal canal" + }, { + "code": "C78.5", + "display": "Secondary malignant neoplasm of large intestine and rectum" + } ] + }, { + "system": "http://hl7.org/fhir/sid/icd-9-cm", + "version": "2013", + "concept": [ { + "code": "153.0", + "display": "Malignant neoplasm of hepatic flexure" + }, { + "code": "153.1", + "display": "Malignant neoplasm of transverse colon" + }, { + "code": "153.2", + "display": "Malignant neoplasm of descending colon" + }, { + "code": "153.3", + "display": "Malignant neoplasm of sigmoid colon" + }, { + "code": "153.4", + "display": "Malignant neoplasm of cecum" + }, { + "code": "153.5", + "display": "Malignant neoplasm of appendix vermiformis" + }, { + "code": "153.6", + "display": "Malignant neoplasm of ascending colon" + }, { + "code": "153.7", + "display": "Malignant neoplasm of splenic flexure" + }, { + "code": "153.8", + "display": "Malignant neoplasm of other specified sites of large intestine" + }, { + "code": "153.9", + "display": "Malignant neoplasm of colon, unspecified site" + }, { + "code": "154.0", + "display": "Malignant neoplasm of rectosigmoid junction" + }, { + "code": "154.1", + "display": "Malignant neoplasm of rectum" + }, { + "code": "197.5", + "display": "Secondary malignant neoplasm of large intestine and rectum" + } ] + }, { + "system": "http://snomed.info/sct", + "version": "2012-07", + "concept": [ { + "code": "187758006", + "display": "Malignant neoplasm of other specified sites of colon (disorder)" + } ] + }, { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "109838007", + "display": "Overlapping malignant neoplasm of colon (disorder)" + }, { + "code": "133751000119102", + "display": "Lymphoma of colon (disorder)" + }, { + "code": "1701000119104", + "display": "Primary adenocarcinoma of colon (disorder)" + }, { + "code": "184881000119106", + "display": "Primary adenocarcinoma of rectosigmoid junction (disorder)" + }, { + "code": "187757001", + "display": "Malignant neoplasm, overlapping lesion of colon (disorder)" + }, { + "code": "269533000", + "display": "Carcinoma of colon (disorder)" + }, { + "code": "269544008", + "display": "Carcinoma of the rectosigmoid junction (disorder)" + }, { + "code": "285312008", + "display": "Carcinoma of sigmoid colon (disorder)" + }, { + "code": "285611007", + "display": "Metastasis to colon of unknown primary (disorder)" + }, { + "code": "301756000", + "display": "Adenocarcinoma of sigmoid colon (disorder)" + }, { + "code": "312111009", + "display": "Carcinoma of ascending colon (disorder)" + }, { + "code": "312112002", + "display": "Carcinoma of transverse colon (disorder)" + }, { + "code": "312113007", + "display": "Carcinoma of descending colon (disorder)" + }, { + "code": "312114001", + "display": "Carcinoma of hepatic flexure (disorder)" + }, { + "code": "312115000", + "display": "Carcinoma of splenic flexure (disorder)" + }, { + "code": "314965007", + "display": "Local recurrence of malignant tumor of colon (disorder)" + }, { + "code": "315058005", + "display": "Hereditary nonpolyposis colon cancer (disorder)" + }, { + "code": "363406005", + "display": "Malignant neoplasm of colon (disorder)" + }, { + "code": "363407001", + "display": "Malignant tumor of hepatic flexure (disorder)" + }, { + "code": "363408006", + "display": "Malignant tumor of transverse colon (disorder)" + }, { + "code": "363409003", + "display": "Malignant tumor of descending colon (disorder)" + }, { + "code": "363410008", + "display": "Malignant tumor of sigmoid colon (disorder)" + }, { + "code": "363412000", + "display": "Malignant tumor of ascending colon (disorder)" + }, { + "code": "363413005", + "display": "Malignant tumor of splenic flexure (disorder)" + }, { + "code": "363414004", + "display": "Malignant tumor of rectosigmoid junction (disorder)" + }, { + "code": "363510005", + "display": "Malignant tumor of large intestine (disorder)" + }, { + "code": "425178004", + "display": "Adenocarcinoma of rectosigmoid junction (disorder)" + }, { + "code": "449218003", + "display": "Lymphoma of sigmoid colon (disorder)" + }, { + "code": "681601000119101", + "display": "Primary adenocarcinoma of ascending colon (disorder)" + }, { + "code": "716654007", + "display": "Non-polyposis Turcot syndrome (disorder)" + }, { + "code": "721695008", + "display": "Primary adenocarcinoma of ascending colon and right flexure (disorder)" + }, { + "code": "721696009", + "display": "Primary adenocarcinoma of transverse colon (disorder)" + }, { + "code": "721699002", + "display": "Primary adenocarcinoma of descending colon and splenic flexure (disorder)" + }, { + "code": "737058005", + "display": "Microsatellite instability-high colorectal cancer (disorder)" + }, { + "code": "93683002", + "display": "Primary malignant neoplasm of ascending colon (disorder)" + }, { + "code": "93761005", + "display": "Primary malignant neoplasm of colon (disorder)" + }, { + "code": "93771007", + "display": "Primary malignant neoplasm of descending colon (disorder)" + }, { + "code": "93826009", + "display": "Primary malignant neoplasm of hepatic flexure of colon (disorder)" + }, { + "code": "93980002", + "display": "Primary malignant neoplasm of rectosigmoid junction (disorder)" + }, { + "code": "94006002", + "display": "Primary malignant neoplasm of sigmoid colon (disorder)" + }, { + "code": "94072004", + "display": "Primary malignant neoplasm of splenic flexure of colon (disorder)" + }, { + "code": "94105000", + "display": "Primary malignant neoplasm of transverse colon (disorder)" + }, { + "code": "94179005", + "display": "Secondary malignant neoplasm of ascending colon (disorder)" + }, { + "code": "94260004", + "display": "Secondary malignant neoplasm of colon (disorder)" + }, { + "code": "94271003", + "display": "Secondary malignant neoplasm of descending colon (disorder)" + }, { + "code": "94328005", + "display": "Secondary malignant neoplasm of hepatic flexure of colon (disorder)" + }, { + "code": "94509004", + "display": "Secondary malignant neoplasm of rectosigmoid junction (disorder)" + }, { + "code": "94538001", + "display": "Secondary malignant neoplasm of sigmoid colon (disorder)" + }, { + "code": "94604000", + "display": "Secondary malignant neoplasm of splenic flexure of colon (disorder)" + }, { + "code": "94643001", + "display": "Secondary malignant neoplasm of transverse colon (disorder)" + }, { + "code": "96281000119107", + "display": "Overlapping malignant neoplasm of colon and rectum (disorder)" + }, { + "code": "96981000119102", + "display": "Malignant neoplasm of rectosigmoid junction metastatic to brain (disorder)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.108.12.1001" + } + }, { + "resource": { + "resourceType": "MeasureReport", + "id": "measurereport-numer-EXM130", + "contained": [ { + "resourceType": "Bundle", + "id": "5c81f095-5b76-43ca-aef9-64fc8d966fc9", + "type": "collection", + "entry": [ { + "fullUrl": "e94b1008-48ed-4453-92b9-e45783e8d8fd", + "resource": { + "resourceType": "List", + "id": "e94b1008-48ed-4453-92b9-e45783e8d8fd", + "title": "initial-population", + "entry": [ { + "item": { + "reference": "numer-EXM130" + } + }, { + "item": { + "reference": "numer-EXM130-4" + } + } ] + } + }, { + "fullUrl": "e207b45d-038c-44af-a551-0243745ca7e7", + "resource": { + "resourceType": "List", + "id": "e207b45d-038c-44af-a551-0243745ca7e7", + "title": "numerator", + "entry": [ { + "item": { + "reference": "numer-EXM130-1" + } + } ] + } + }, { + "fullUrl": "Patient/numer-EXM130", + "resource": { + "resourceType": "Patient", + "id": "numer-EXM130", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, + "extension": [ { + "url": "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race", + "extension": [ { + "url": "ombCategory", + "valueCoding": { + "system": "urn:oid:2.16.840.1.113883.6.238", + "code": "2028-9", + "display": "Asian" + } + } ] + }, { + "url": "http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity", + "extension": [ { + "url": "ombCategory", + "valueCoding": { + "system": "urn:oid:2.16.840.1.113883.6.238", + "code": "2135-2", + "display": "Hispanic or Latino" + } + } ] + } ], + "identifier": [ { + "use": "usual", + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/v2-0203", + "code": "MR", + "display": "Medical Record Number" + } ] + }, + "system": "http://hospital.smarthealthit.org", + "value": "999999992" + } ], + "name": [ { + "family": "Blitz", + "given": [ "Don" ] + } ], + "gender": "male", + "birthDate": "1965-01-01" + } + }, { + "fullUrl": "Encounter/numer-EXM130-4", + "resource": { + "resourceType": "Encounter", + "id": "numer-EXM130-4", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" ] + }, + "status": "finished", + "class": { + "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode", + "code": "AMB", + "display": "ambulatory" + }, + "type": [ { + "coding": [ { + "system": "http://www.ama-assn.org/go/cpt", + "code": "99201", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: A problem focused history; A problem focused examination; Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are self limited or minor. Typically, 10 minutes are spent face-to-face with the patient and/or family." + } ] + } ], + "subject": { + "reference": "Patient/numer-EXM130" + }, + "period": { + "start": "2019-05-30T00:00:00.0", + "end": "2019-05-31T00:00:00.0" + } + } + }, { + "fullUrl": "Procedure/numer-EXM130-1", + "resource": { + "resourceType": "Procedure", + "id": "numer-EXM130-1", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" ] + }, + "status": "completed", + "code": { + "coding": [ { + "system": "http://www.ama-assn.org/go/cpt", + "code": "44393", + "display": "Colonoscopy through stoma; with ablation of tumor(s), polyp(s), or other lesion(s) not amenable to removal by hot biopsy forceps, bipolar cautery or snare technique" + } ] + }, + "subject": { + "reference": "Patient/numer-EXM130" + }, + "performedPeriod": { + "start": "2010-01-01T00:00:00-06:00", + "end": "2010-01-01T01:00:00-07:00" + } + } + } ] + } ], + "status": "complete", + "type": "individual", + "measure": "Measure/measure-EXM130-7.3.000", + "subject": { + "reference": "Patient/numer-EXM130" + }, + "period": { + "start": "2018-12-31T17:00:00-07:00", + "end": "2019-12-30T17:00:00-07:00" + }, + "group": [ { + "id": "group-1", + "population": [ { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } ] + }, + "count": 1 + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } ] + }, + "count": 1 + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } ] + }, + "count": 1 + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } ] + }, + "count": 0 + } ], + "measureScore": { + "value": 1.0 + } + } ], + "evaluatedResource": [ { + "reference": "#5c81f095-5b76-43ca-aef9-64fc8d966fc9" + } ] + }, + "request": { + "method": "PUT", + "url": "MeasureReport/measurereport-numer-EXM130" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.108.12.1020", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1020", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.108.12.1020" + } ], + "version": "20171219", + "name": "Colonoscopy", + "title": "Colonoscopy", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2014", + "concept": [ { + "code": "44393", + "display": "Colonoscopy through stoma; with ablation of tumor(s), polyp(s), or other lesion(s) not amenable to removal by hot biopsy forceps, bipolar cautery or snare technique" + }, { + "code": "44397", + "display": "Colonoscopy through stoma; with transendoscopic stent placement (includes predilation)" + }, { + "code": "45355", + "display": "Colonoscopy, rigid or flexible, transabdominal via colotomy, single or multiple" + }, { + "code": "45383", + "display": "Colonoscopy, flexible, proximal to splenic flexure; with ablation of tumor(s), polyp(s), or other lesion(s) not amenable to removal by hot biopsy forceps, bipolar cautery or snare technique" + }, { + "code": "45387", + "display": "Colonoscopy, flexible, proximal to splenic flexure; with transendoscopic stent placement (includes predilation)" + } ] + }, { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2018", + "concept": [ { + "code": "44388", + "display": "Colonoscopy through stoma; diagnostic, including collection of specimen(s) by brushing or washing, when performed (separate procedure)" + }, { + "code": "44389", + "display": "Colonoscopy through stoma; with biopsy, single or multiple" + }, { + "code": "44390", + "display": "Colonoscopy through stoma; with removal of foreign body(s)" + }, { + "code": "44391", + "display": "Colonoscopy through stoma; with control of bleeding, any method" + }, { + "code": "44392", + "display": "Colonoscopy through stoma; with removal of tumor(s), polyp(s), or other lesion(s) by hot biopsy forceps" + }, { + "code": "44394", + "display": "Colonoscopy through stoma; with removal of tumor(s), polyp(s), or other lesion(s) by snare technique" + }, { + "code": "44401", + "display": "Colonoscopy through stoma; with ablation of tumor(s), polyp(s), or other lesion(s) (includes pre-and post-dilation and guide wire passage, when performed)" + }, { + "code": "44402", + "display": "Colonoscopy through stoma; with endoscopic stent placement (including pre- and post-dilation and guide wire passage, when performed)" + }, { + "code": "44403", + "display": "Colonoscopy through stoma; with endoscopic mucosal resection" + }, { + "code": "44404", + "display": "Colonoscopy through stoma; with directed submucosal injection(s), any substance" + }, { + "code": "44405", + "display": "Colonoscopy through stoma; with transendoscopic balloon dilation" + }, { + "code": "44406", + "display": "Colonoscopy through stoma; with endoscopic ultrasound examination, limited to the sigmoid, descending, transverse, or ascending colon and cecum and adjacent structures" + }, { + "code": "44407", + "display": "Colonoscopy through stoma; with transendoscopic ultrasound guided intramural or transmural fine needle aspiration/biopsy(s), includes endoscopic ultrasound examination limited to the sigmoid, descending, transverse, or ascending colon and cecum and adjacent structures" + }, { + "code": "44408", + "display": "Colonoscopy through stoma; with decompression (for pathologic distention) (eg, volvulus, megacolon), including placement of decompression tube, when performed" + }, { + "code": "45378", + "display": "Colonoscopy, flexible; diagnostic, including collection of specimen(s) by brushing or washing, when performed (separate procedure)" + }, { + "code": "45379", + "display": "Colonoscopy, flexible; with removal of foreign body(s)" + }, { + "code": "45380", + "display": "Colonoscopy, flexible; with biopsy, single or multiple" + }, { + "code": "45381", + "display": "Colonoscopy, flexible; with directed submucosal injection(s), any substance" + }, { + "code": "45382", + "display": "Colonoscopy, flexible; with control of bleeding, any method" + }, { + "code": "45384", + "display": "Colonoscopy, flexible; with removal of tumor(s), polyp(s), or other lesion(s) by hot biopsy forceps" + }, { + "code": "45385", + "display": "Colonoscopy, flexible; with removal of tumor(s), polyp(s), or other lesion(s) by snare technique" + }, { + "code": "45386", + "display": "Colonoscopy, flexible; with transendoscopic balloon dilation" + }, { + "code": "45388", + "display": "Colonoscopy, flexible; with ablation of tumor(s), polyp(s), or other lesion(s) (includes pre- and post-dilation and guide wire passage, when performed)" + }, { + "code": "45389", + "display": "Colonoscopy, flexible; with endoscopic stent placement (includes pre- and post-dilation and guide wire passage, when performed)" + }, { + "code": "45390", + "display": "Colonoscopy, flexible; with endoscopic mucosal resection" + }, { + "code": "45391", + "display": "Colonoscopy, flexible; with endoscopic ultrasound examination limited to the rectum, sigmoid, descending, transverse, or ascending colon and cecum, and adjacent structures" + }, { + "code": "45392", + "display": "Colonoscopy, flexible; with transendoscopic ultrasound guided intramural or transmural fine needle aspiration/biopsy(s), includes endoscopic ultrasound examination limited to the rectum, sigmoid, descending, transverse, or ascending colon and cecum, and adjacent structures" + }, { + "code": "45393", + "display": "Colonoscopy, flexible; with decompression (for pathologic distention) (eg, volvulus, megacolon), including placement of decompression tube, when performed" + }, { + "code": "45398", + "display": "Colonoscopy, flexible; with band ligation(s) (eg, hemorrhoids)" + } ] + }, { + "system": "https://www.cms.gov/Medicare/Coding/MedHCPCSGenInfo/index.html", + "version": "2018", + "concept": [ { + "code": "G0105", + "display": "Colorectal cancer screening; colonoscopy on individual at high risk" + }, { + "code": "G0121", + "display": "Colorectal cancer screening; colonoscopy on individual not meeting criteria for high risk" + } ] + }, { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "12350003", + "display": "Colonoscopy with rigid sigmoidoscope through colotomy (procedure)" + }, { + "code": "174158000", + "display": "Open colonoscopy (procedure)" + }, { + "code": "235150006", + "display": "Total colonoscopy (procedure)" + }, { + "code": "235151005", + "display": "Limited colonoscopy (procedure)" + }, { + "code": "25732003", + "display": "Fiberoptic colonoscopy with biopsy (procedure)" + }, { + "code": "310634005", + "display": "Check colonoscopy (procedure)" + }, { + "code": "34264006", + "display": "Intraoperative colonoscopy (procedure)" + }, { + "code": "367535003", + "display": "Fiberoptic colonoscopy (procedure)" + }, { + "code": "425672002", + "display": "Diagnostic endoscopic examination of ileoanal pouch and biopsy of ileoanal pouch using colonoscope (procedure)" + }, { + "code": "425937002", + "display": "Diagnostic endoscopic examination of enteric pouch using colonoscope (procedure)" + }, { + "code": "427459009", + "display": "Diagnostic endoscopic examination of colonic pouch and biopsy of colonic pouch using colonoscope (procedure)" + }, { + "code": "443998000", + "display": "Colonoscopy through colostomy with endoscopic biopsy of colon (procedure)" + }, { + "code": "444783004", + "display": "Screening colonoscopy (procedure)" + }, { + "code": "446521004", + "display": "Colonoscopy and excision of mucosa of colon (procedure)" + }, { + "code": "446745002", + "display": "Colonoscopy and biopsy of colon (procedure)" + }, { + "code": "447021001", + "display": "Colonoscopy and tattooing (procedure)" + }, { + "code": "709421007", + "display": "Colonoscopy and dilatation of stricture of colon (procedure)" + }, { + "code": "710293001", + "display": "Colonoscopy using fluoroscopic guidance (procedure)" + }, { + "code": "711307001", + "display": "Colonoscopy using X-ray guidance (procedure)" + }, { + "code": "713154003", + "display": "Endoscopic submucosal dissection of rectum using colonoscope (procedure)" + }, { + "code": "73761001", + "display": "Colonoscopy (procedure)" + }, { + "code": "8180007", + "display": "Fiberoptic colonoscopy through colostomy (procedure)" + }, { + "code": "851000119109", + "display": "History of colonoscopy (situation)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.108.12.1020" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.101.12.1016", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.101.12.1016" + } ], + "version": "20180310", + "name": "HomeHealthcareServices", + "title": "Home Healthcare Services", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2018", + "concept": [ { + "code": "99341", + "display": "Home visit for the evaluation and management of a new patient, which requires these 3 key components: A problem focused history; A problem focused examination; and Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of low severity. Typically, 20 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99342", + "display": "Home visit for the evaluation and management of a new patient, which requires these 3 key components: An expanded problem focused history; An expanded problem focused examination; and Medical decision making of low complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of moderate severity. Typically, 30 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99343", + "display": "Home visit for the evaluation and management of a new patient, which requires these 3 key components: A detailed history; A detailed examination; and Medical decision making of moderate complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of moderate to high severity. Typically, 45 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99344", + "display": "Home visit for the evaluation and management of a new patient, which requires these 3 key components: A comprehensive history; A comprehensive examination; and Medical decision making of moderate complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of high severity. Typically, 60 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99345", + "display": "Home visit for the evaluation and management of a new patient, which requires these 3 key components: A comprehensive history; A comprehensive examination; and Medical decision making of high complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the patient is unstable or has developed a significant new problem requiring immediate physician attention. Typically, 75 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99347", + "display": "Home visit for the evaluation and management of an established patient, which requires at least 2 of these 3 key components: A problem focused interval history; A problem focused examination; Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are self limited or minor. Typically, 15 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99348", + "display": "Home visit for the evaluation and management of an established patient, which requires at least 2 of these 3 key components: An expanded problem focused interval history; An expanded problem focused examination; Medical decision making of low complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of low to moderate severity. Typically, 25 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99349", + "display": "Home visit for the evaluation and management of an established patient, which requires at least 2 of these 3 key components: A detailed interval history; A detailed examination; Medical decision making of moderate complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are moderate to high severity. Typically, 40 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99350", + "display": "Home visit for the evaluation and management of an established patient, which requires at least 2 of these 3 key components: A comprehensive interval history; A comprehensive examination; Medical decision making of moderate to high complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of moderate to high severity. The patient may be unstable or may have developed a significant new problem requiring immediate physician attention. Typically, 60 minutes are spent face-to-face with the patient and/or family." + } ] + }, { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "185460008", + "display": "Home visit request by patient (procedure)" + }, { + "code": "185462000", + "display": "Home visit request by relative (procedure)" + }, { + "code": "185466002", + "display": "Home visit for urgent condition (procedure)" + }, { + "code": "185467006", + "display": "Home visit for acute condition (procedure)" + }, { + "code": "185468001", + "display": "Home visit for chronic condition (procedure)" + }, { + "code": "185470005", + "display": "Home visit elderly assessment (procedure)" + }, { + "code": "225929007", + "display": "Joint home visit (procedure)" + }, { + "code": "315205008", + "display": "Bank holiday home visit (procedure)" + }, { + "code": "439708006", + "display": "Home visit (procedure)" + }, { + "code": "698704008", + "display": "Home visit for rheumatology service (procedure)" + }, { + "code": "704126008", + "display": "Home visit for anticoagulant drug monitoring (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + }, { + "resource": { + "resourceType": "Library", + "id": "library-Hospice-2.0.000", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "#cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/dbcg/connectathon/Library/Hospice", + "version": "2.0.000", + "name": "Hospice", + "status": "active", + "experimental": true, + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } ] + }, + "relatedArtifact": [ { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "resource": "http://fhir.org/guides/dbcg/connectathon/Library/MATGlobalCommonFunctions|5.0.000" + }, { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIRHelpers|4.0.1" + }, { + "type": "depends-on", + "resource": "http://snomed.info/sct/731000124108|http://snomed.info/sct/731000124108/version/201709" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1108.15" + } ], + "parameter": [ { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Patient" + }, { + "name": "Has Hospice", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + } ], + "dataRequirement": [ { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } ] + }, { + "type": "ServiceRequest", + "profile": [ "http://hl7.org/fhir/StructureDefinition/ServiceRequest" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1108.15" + } ] + }, { + "type": "Procedure", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Procedure" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1108.15" + } ] + } ], + "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 translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <identifier id="Hospice" system="http://fhir.org/guides/dbcg/connectathon" version="2.0.000"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="17:1-17:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1"/>
   </usings>
   <includes>
      <def localId="2" locator="19:1-19:64" localIdentifier="Global" path="http://fhir.org/guides/dbcg/connectathon/MATGlobalCommonFunctions" version="5.0.000"/>
      <def localId="3" locator="20:1-20:54" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/dbcg/connectathon/FHIRHelpers" version="4.0.1"/>
   </includes>
   <parameters>
      <def localId="16" locator="30:1-31:66" name="Measurement Period" accessLevel="Public">
         <default localId="13" locator="31:11-31:66" lowClosed="true" highClosed="false" xsi:type="Interval">
            <low localId="11" locator="31:20-31:41" xsi:type="DateTime">
               <year valueType="t:Integer" value="2019" xsi:type="Literal"/>
               <month valueType="t:Integer" value="1" xsi:type="Literal"/>
               <day valueType="t:Integer" value="1" xsi:type="Literal"/>
               <hour valueType="t:Integer" value="0" xsi:type="Literal"/>
               <minute valueType="t:Integer" value="0" xsi:type="Literal"/>
               <second valueType="t:Integer" value="0" xsi:type="Literal"/>
               <millisecond valueType="t:Integer" value="0" xsi:type="Literal"/>
            </low>
            <high localId="12" locator="31:44-31:65" xsi:type="DateTime">
               <year valueType="t:Integer" value="2020" xsi:type="Literal"/>
               <month valueType="t:Integer" value="1" xsi:type="Literal"/>
               <day valueType="t:Integer" value="1" xsi:type="Literal"/>
               <hour valueType="t:Integer" value="0" xsi:type="Literal"/>
               <minute valueType="t:Integer" value="0" xsi:type="Literal"/>
               <second valueType="t:Integer" value="0" xsi:type="Literal"/>
               <millisecond valueType="t:Integer" value="0" xsi:type="Literal"/>
            </high>
         </default>
         <parameterTypeSpecifier localId="15" locator="30:32-30:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="14" locator="30:41-30:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <codeSystems>
      <def localId="4" locator="22:1-22:129" name="SNOMEDCT:2017-09" id="http://snomed.info/sct/731000124108" version="http://snomed.info/sct/731000124108/version/201709" accessLevel="Public"/>
   </codeSystems>
   <valueSets>
      <def localId="5" locator="24:1-24:100" name="Encounter Inpatient" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" accessLevel="Public"/>
      <def localId="6" locator="25:1-25:104" name="Hospice care ambulatory" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1108.15" accessLevel="Public"/>
   </valueSets>
   <codes>
      <def localId="8" locator="27:1-27:183" name="Discharge to healthcare facility for hospice care (procedure)" id="428371000124100" display="Discharge to healthcare facility for hospice care (procedure)" accessLevel="Public">
         <codeSystem localId="7" locator="27:94-27:111" name="SNOMEDCT:2017-09"/>
      </def>
      <def localId="10" locator="28:1-28:153" name="Discharge to home for hospice care (procedure)" id="428361000124107" display="Discharge to home for hospice care (procedure)" accessLevel="Public">
         <codeSystem localId="9" locator="28:79-28:96" name="SNOMEDCT:2017-09"/>
      </def>
   </codes>
   <statements>
      <def locator="33:1-33:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="33:1-33:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/StructureDefinition/Patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="72" locator="35:1-54:5" name="Has Hospice" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="72">
               <a:s>define &quot;Has Hospice&quot;:&#xd;
	</a:s>
               <a:s r="71">
                  <a:s r="55">
                     <a:s r="41">
                        <a:s>exists </a:s>
                        <a:s r="40">
                           <a:s>(&#xd;
    </a:s>
                           <a:s r="40">
                              <a:s>
                                 <a:s r="18">
                                    <a:s r="17">
                                       <a:s r="17">
                                          <a:s>[Encounter: </a:s>
                                          <a:s>
                                             <a:s>&quot;Encounter Inpatient&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> DischargeHospice</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>&#xd;
			</a:s>
                              <a:s r="39">
                                 <a:s>where </a:s>
                                 <a:s r="39">
                                    <a:s r="34">
                                       <a:s r="22">
                                          <a:s r="20">
                                             <a:s r="19">
                                                <a:s>DischargeHospice</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="20">
                                                <a:s>status</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> = </a:s>
                                          <a:s r="21">
                                             <a:s>'finished'</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>&#xd;
		    and </a:s>
                                       <a:s r="33">
                                          <a:s>(&#xd;
	        </a:s>
                                          <a:s r="33">
                                             <a:s r="27">
                                                <a:s r="25">
                                                   <a:s r="24">
                                                      <a:s r="23">
                                                         <a:s>DischargeHospice</a:s>
                                                      </a:s>
                                                      <a:s>.</a:s>
                                                      <a:s r="24">
                                                         <a:s>hospitalization</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="25">
                                                      <a:s>dischargeDisposition</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s> ~ </a:s>
                                                <a:s r="26">
                                                   <a:s>&quot;Discharge to home for hospice care (procedure)&quot;</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>&#xd;
				    or </a:s>
                                             <a:s r="32">
                                                <a:s r="30">
                                                   <a:s r="29">
                                                      <a:s r="28">
                                                         <a:s>DischargeHospice</a:s>
                                                      </a:s>
                                                      <a:s>.</a:s>
                                                      <a:s r="29">
                                                         <a:s>hospitalization</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="30">
                                                      <a:s>dischargeDisposition</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s> ~ </a:s>
                                                <a:s r="31">
                                                   <a:s>&quot;Discharge to healthcare facility for hospice care (procedure)&quot;</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>&#xd;
	    	)</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>&#xd;
				and </a:s>
                                    <a:s r="38">
                                       <a:s r="36">
                                          <a:s r="35">
                                             <a:s>DischargeHospice</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="36">
                                             <a:s>period</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s r="38"> ends during </a:s>
                                       <a:s r="37">
                                          <a:s>&quot;Measurement Period&quot;</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
	)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
    or </a:s>
                     <a:s r="54">
                        <a:s>exists </a:s>
                        <a:s r="53">
                           <a:s>(&#xd;
      </a:s>
                           <a:s r="53">
                              <a:s>
                                 <a:s r="43">
                                    <a:s r="42">
                                       <a:s r="42">
                                          <a:s>[ServiceRequest: </a:s>
                                          <a:s>
                                             <a:s>&quot;Hospice care ambulatory&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> HospiceOrder</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>&#xd;
        </a:s>
                              <a:s r="52">
                                 <a:s>where </a:s>
                                 <a:s r="52">
                                    <a:s r="47">
                                       <a:s r="45">
                                          <a:s r="44">
                                             <a:s>HospiceOrder</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="45">
                                             <a:s>intent</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> = </a:s>
                                       <a:s r="46">
                                          <a:s>'order'</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>&#xd;
            and </a:s>
                                    <a:s r="51">
                                       <a:s r="49">
                                          <a:s r="48">
                                             <a:s>HospiceOrder</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="49">
                                             <a:s>authoredOn</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> in </a:s>
                                       <a:s r="50">
                                          <a:s>&quot;Measurement Period&quot;</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
    )</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
    or </a:s>
                  <a:s r="70">
                     <a:s>exists </a:s>
                     <a:s r="69">
                        <a:s>(&#xd;
      </a:s>
                        <a:s r="69">
                           <a:s>
                              <a:s r="57">
                                 <a:s r="56">
                                    <a:s r="56">
                                       <a:s>[Procedure: </a:s>
                                       <a:s>
                                          <a:s>&quot;Hospice care ambulatory&quot;</a:s>
                                       </a:s>
                                       <a:s>]</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> HospicePerformed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
        </a:s>
                           <a:s r="68">
                              <a:s>where </a:s>
                              <a:s r="68">
                                 <a:s r="61">
                                    <a:s r="59">
                                       <a:s r="58">
                                          <a:s>HospicePerformed</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="59">
                                          <a:s>status</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> = </a:s>
                                    <a:s r="60">
                                       <a:s>'completed'</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
          and </a:s>
                                 <a:s r="67">
                                    <a:s r="65">
                                       <a:s r="62">
                                          <a:s>Global</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="65">
                                          <a:s>&quot;Normalize Interval&quot;(</a:s>
                                          <a:s r="64">
                                             <a:s r="63">
                                                <a:s>HospicePerformed</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="64">
                                                <a:s>performed</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>)</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s r="67"> overlaps </a:s>
                                    <a:s r="66">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
    )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="71" locator="36:2-54:5" xsi:type="Or">
            <operand localId="55" locator="36:2-49:5" xsi:type="Or">
               <operand localId="41" locator="36:2-44:2" xsi:type="Exists">
                  <operand localId="40" locator="36:9-44:2" xsi:type="Query">
                     <source localId="18" locator="37:5-37:55" alias="DischargeHospice">
                        <expression localId="17" locator="37:5-37:38" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                           <codes locator="37:17-37:37" name="Encounter Inpatient" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="39" locator="38:4-43:64" xsi:type="And">
                        <operand localId="34" locator="38:10-42:7" xsi:type="And">
                           <operand localId="22" locator="38:10-38:45" xsi:type="Equal">
                              <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="20" locator="38:10-38:32" path="status" scope="DischargeHospice" xsi:type="Property"/>
                              </operand>
                              <operand localId="21" locator="38:36-38:45" valueType="t:String" value="finished" xsi:type="Literal"/>
                           </operand>
                           <operand localId="33" locator="39:11-42:7" xsi:type="Or">
                              <operand localId="27" locator="40:10-40:113" xsi:type="Equivalent">
                                 <operand name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="25" locator="40:10-40:62" path="dischargeDisposition" xsi:type="Property">
                                       <source localId="24" locator="40:10-40:41" path="hospitalization" scope="DischargeHospice" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <operand xsi:type="ToConcept">
                                    <operand localId="26" locator="40:66-40:113" name="Discharge to home for hospice care (procedure)" xsi:type="CodeRef"/>
                                 </operand>
                              </operand>
                              <operand localId="32" locator="41:12-41:130" xsi:type="Equivalent">
                                 <operand name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="30" locator="41:12-41:64" path="dischargeDisposition" xsi:type="Property">
                                       <source localId="29" locator="41:12-41:43" path="hospitalization" scope="DischargeHospice" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <operand xsi:type="ToConcept">
                                    <operand localId="31" locator="41:68-41:130" name="Discharge to healthcare facility for hospice care (procedure)" xsi:type="CodeRef"/>
                                 </operand>
                              </operand>
                           </operand>
                        </operand>
                        <operand localId="38" locator="43:9-43:64" xsi:type="In">
                           <operand locator="43:33-43:36" xsi:type="End">
                              <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="36" locator="43:9-43:31" path="period" scope="DischargeHospice" xsi:type="Property"/>
                              </operand>
                           </operand>
                           <operand localId="37" locator="43:45-43:64" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </where>
                  </operand>
               </operand>
               <operand localId="54" locator="45:8-49:5" xsi:type="Exists">
                  <operand localId="53" locator="45:15-49:5" xsi:type="Query">
                     <source localId="43" locator="46:7-46:62" alias="HospiceOrder">
                        <expression localId="42" locator="46:7-46:49" dataType="fhir:ServiceRequest" templateId="http://hl7.org/fhir/StructureDefinition/ServiceRequest" codeProperty="code" xsi:type="Retrieve">
                           <codes locator="46:24-46:48" name="Hospice care ambulatory" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="52" locator="47:9-48:63" xsi:type="And">
                        <operand localId="47" locator="47:15-47:43" xsi:type="Equal">
                           <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="45" locator="47:15-47:33" path="intent" scope="HospiceOrder" xsi:type="Property"/>
                           </operand>
                           <operand localId="46" locator="47:37-47:43" valueType="t:String" value="order" xsi:type="Literal"/>
                        </operand>
                        <operand localId="51" locator="48:17-48:63" xsi:type="In">
                           <operand name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="49" locator="48:17-48:39" path="authoredOn" scope="HospiceOrder" xsi:type="Property"/>
                           </operand>
                           <operand localId="50" locator="48:44-48:63" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </where>
                  </operand>
               </operand>
            </operand>
            <operand localId="70" locator="50:8-54:5" xsi:type="Exists">
               <operand localId="69" locator="50:15-54:5" xsi:type="Query">
                  <source localId="57" locator="51:7-51:61" alias="HospicePerformed">
                     <expression localId="56" locator="51:7-51:44" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/StructureDefinition/Procedure" codeProperty="code" xsi:type="Retrieve">
                        <codes locator="51:19-51:43" name="Hospice care ambulatory" xsi:type="ValueSetRef"/>
                     </expression>
                  </source>
                  <where localId="68" locator="52:9-53:99" xsi:type="And">
                     <operand localId="61" locator="52:15-52:51" xsi:type="Equal">
                        <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="59" locator="52:15-52:37" path="status" scope="HospicePerformed" xsi:type="Property"/>
                        </operand>
                        <operand localId="60" locator="52:41-52:51" valueType="t:String" value="completed" xsi:type="Literal"/>
                     </operand>
                     <operand localId="67" locator="53:15-53:99" xsi:type="Overlaps">
                        <operand localId="65" locator="53:15-53:69" name="Normalize Interval" libraryName="Global" xsi:type="FunctionRef">
                           <operand localId="64" locator="53:43-53:68" path="performed" scope="HospicePerformed" xsi:type="Property"/>
                        </operand>
                        <operand localId="66" locator="53:80-53:99" name="Measurement Period" xsi:type="ParameterRef"/>
                     </operand>
                  </where>
               </operand>
            </operand>
         </expression>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      } ],
      "identifier" : {
         "id" : "Hospice",
         "system" : "http://fhir.org/guides/dbcg/connectathon",
         "version" : "2.0.000"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "17:1-17:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1"
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "2",
            "locator" : "19:1-19:64",
            "localIdentifier" : "Global",
            "path" : "http://fhir.org/guides/dbcg/connectathon/MATGlobalCommonFunctions",
            "version" : "5.0.000"
         }, {
            "localId" : "3",
            "locator" : "20:1-20:54",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/dbcg/connectathon/FHIRHelpers",
            "version" : "4.0.1"
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "16",
            "locator" : "30:1-31:66",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "default" : {
               "localId" : "13",
               "locator" : "31:11-31:66",
               "lowClosed" : true,
               "highClosed" : false,
               "type" : "Interval",
               "low" : {
                  "localId" : "11",
                  "locator" : "31:20-31:41",
                  "type" : "DateTime",
                  "year" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2019",
                     "type" : "Literal"
                  },
                  "month" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "day" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "hour" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "minute" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "second" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "millisecond" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               },
               "high" : {
                  "localId" : "12",
                  "locator" : "31:44-31:65",
                  "type" : "DateTime",
                  "year" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2020",
                     "type" : "Literal"
                  },
                  "month" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "day" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "hour" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "minute" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "second" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "millisecond" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               }
            },
            "parameterTypeSpecifier" : {
               "localId" : "15",
               "locator" : "30:32-30:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "14",
                  "locator" : "30:41-30:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "4",
            "locator" : "22:1-22:129",
            "name" : "SNOMEDCT:2017-09",
            "id" : "http://snomed.info/sct/731000124108",
            "version" : "http://snomed.info/sct/731000124108/version/201709",
            "accessLevel" : "Public"
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "5",
            "locator" : "24:1-24:100",
            "name" : "Encounter Inpatient",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307",
            "accessLevel" : "Public"
         }, {
            "localId" : "6",
            "locator" : "25:1-25:104",
            "name" : "Hospice care ambulatory",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1108.15",
            "accessLevel" : "Public"
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "8",
            "locator" : "27:1-27:183",
            "name" : "Discharge to healthcare facility for hospice care (procedure)",
            "id" : "428371000124100",
            "display" : "Discharge to healthcare facility for hospice care (procedure)",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "7",
               "locator" : "27:94-27:111",
               "name" : "SNOMEDCT:2017-09"
            }
         }, {
            "localId" : "10",
            "locator" : "28:1-28:153",
            "name" : "Discharge to home for hospice care (procedure)",
            "id" : "428361000124107",
            "display" : "Discharge to home for hospice care (procedure)",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "9",
               "locator" : "28:79-28:96",
               "name" : "SNOMEDCT:2017-09"
            }
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "33:1-33:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "33:1-33:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/StructureDefinition/Patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "72",
            "locator" : "35:1-54:5",
            "name" : "Has Hospice",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "72",
                  "s" : [ {
                     "value" : [ "define ","\"Has Hospice\"",":\r\n\t" ]
                  }, {
                     "r" : "71",
                     "s" : [ {
                        "r" : "55",
                        "s" : [ {
                           "r" : "41",
                           "s" : [ {
                              "value" : [ "exists " ]
                           }, {
                              "r" : "40",
                              "s" : [ {
                                 "value" : [ "(\r\n    " ]
                              }, {
                                 "r" : "40",
                                 "s" : [ {
                                    "s" : [ {
                                       "r" : "18",
                                       "s" : [ {
                                          "r" : "17",
                                          "s" : [ {
                                             "r" : "17",
                                             "s" : [ {
                                                "value" : [ "[","Encounter",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Encounter Inpatient\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","DischargeHospice" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\r\n\t\t\t" ]
                                 }, {
                                    "r" : "39",
                                    "s" : [ {
                                       "value" : [ "where " ]
                                    }, {
                                       "r" : "39",
                                       "s" : [ {
                                          "r" : "34",
                                          "s" : [ {
                                             "r" : "22",
                                             "s" : [ {
                                                "r" : "20",
                                                "s" : [ {
                                                   "r" : "19",
                                                   "s" : [ {
                                                      "value" : [ "DischargeHospice" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "20",
                                                   "s" : [ {
                                                      "value" : [ "status" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","="," " ]
                                             }, {
                                                "r" : "21",
                                                "s" : [ {
                                                   "value" : [ "'finished'" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "\r\n\t\t    and " ]
                                          }, {
                                             "r" : "33",
                                             "s" : [ {
                                                "value" : [ "(\r\n\t        " ]
                                             }, {
                                                "r" : "33",
                                                "s" : [ {
                                                   "r" : "27",
                                                   "s" : [ {
                                                      "r" : "25",
                                                      "s" : [ {
                                                         "r" : "24",
                                                         "s" : [ {
                                                            "r" : "23",
                                                            "s" : [ {
                                                               "value" : [ "DischargeHospice" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ "." ]
                                                         }, {
                                                            "r" : "24",
                                                            "s" : [ {
                                                               "value" : [ "hospitalization" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "25",
                                                         "s" : [ {
                                                            "value" : [ "dischargeDisposition" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " ","~"," " ]
                                                   }, {
                                                      "r" : "26",
                                                      "s" : [ {
                                                         "value" : [ "\"Discharge to home for hospice care (procedure)\"" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\r\n\t\t\t\t    or " ]
                                                }, {
                                                   "r" : "32",
                                                   "s" : [ {
                                                      "r" : "30",
                                                      "s" : [ {
                                                         "r" : "29",
                                                         "s" : [ {
                                                            "r" : "28",
                                                            "s" : [ {
                                                               "value" : [ "DischargeHospice" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ "." ]
                                                         }, {
                                                            "r" : "29",
                                                            "s" : [ {
                                                               "value" : [ "hospitalization" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "30",
                                                         "s" : [ {
                                                            "value" : [ "dischargeDisposition" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " ","~"," " ]
                                                   }, {
                                                      "r" : "31",
                                                      "s" : [ {
                                                         "value" : [ "\"Discharge to healthcare facility for hospice care (procedure)\"" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\r\n\t    \t)" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\r\n\t\t\t\tand " ]
                                       }, {
                                          "r" : "38",
                                          "s" : [ {
                                             "r" : "36",
                                             "s" : [ {
                                                "r" : "35",
                                                "s" : [ {
                                                   "value" : [ "DischargeHospice" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "36",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             } ]
                                          }, {
                                             "r" : "38",
                                             "value" : [ " ","ends during"," " ]
                                          }, {
                                             "r" : "37",
                                             "s" : [ {
                                                "value" : [ "\"Measurement Period\"" ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n\t)" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n    or " ]
                        }, {
                           "r" : "54",
                           "s" : [ {
                              "value" : [ "exists " ]
                           }, {
                              "r" : "53",
                              "s" : [ {
                                 "value" : [ "(\r\n      " ]
                              }, {
                                 "r" : "53",
                                 "s" : [ {
                                    "s" : [ {
                                       "r" : "43",
                                       "s" : [ {
                                          "r" : "42",
                                          "s" : [ {
                                             "r" : "42",
                                             "s" : [ {
                                                "value" : [ "[","ServiceRequest",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Hospice care ambulatory\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","HospiceOrder" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\r\n        " ]
                                 }, {
                                    "r" : "52",
                                    "s" : [ {
                                       "value" : [ "where " ]
                                    }, {
                                       "r" : "52",
                                       "s" : [ {
                                          "r" : "47",
                                          "s" : [ {
                                             "r" : "45",
                                             "s" : [ {
                                                "r" : "44",
                                                "s" : [ {
                                                   "value" : [ "HospiceOrder" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "45",
                                                "s" : [ {
                                                   "value" : [ "intent" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","="," " ]
                                          }, {
                                             "r" : "46",
                                             "s" : [ {
                                                "value" : [ "'order'" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\r\n            and " ]
                                       }, {
                                          "r" : "51",
                                          "s" : [ {
                                             "r" : "49",
                                             "s" : [ {
                                                "r" : "48",
                                                "s" : [ {
                                                   "value" : [ "HospiceOrder" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "49",
                                                "s" : [ {
                                                   "value" : [ "authoredOn" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " in " ]
                                          }, {
                                             "r" : "50",
                                             "s" : [ {
                                                "value" : [ "\"Measurement Period\"" ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n    )" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n    or " ]
                     }, {
                        "r" : "70",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "69",
                           "s" : [ {
                              "value" : [ "(\r\n      " ]
                           }, {
                              "r" : "69",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "57",
                                    "s" : [ {
                                       "r" : "56",
                                       "s" : [ {
                                          "r" : "56",
                                          "s" : [ {
                                             "value" : [ "[","Procedure",": " ]
                                          }, {
                                             "s" : [ {
                                                "value" : [ "\"Hospice care ambulatory\"" ]
                                             } ]
                                          }, {
                                             "value" : [ "]" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","HospicePerformed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n        " ]
                              }, {
                                 "r" : "68",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "68",
                                    "s" : [ {
                                       "r" : "61",
                                       "s" : [ {
                                          "r" : "59",
                                          "s" : [ {
                                             "r" : "58",
                                             "s" : [ {
                                                "value" : [ "HospicePerformed" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "59",
                                             "s" : [ {
                                                "value" : [ "status" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","="," " ]
                                       }, {
                                          "r" : "60",
                                          "s" : [ {
                                             "value" : [ "'completed'" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n          and " ]
                                    }, {
                                       "r" : "67",
                                       "s" : [ {
                                          "r" : "65",
                                          "s" : [ {
                                             "r" : "62",
                                             "s" : [ {
                                                "value" : [ "Global" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "65",
                                             "s" : [ {
                                                "value" : [ "\"Normalize Interval\"","(" ]
                                             }, {
                                                "r" : "64",
                                                "s" : [ {
                                                   "r" : "63",
                                                   "s" : [ {
                                                      "value" : [ "HospicePerformed" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "64",
                                                   "s" : [ {
                                                      "value" : [ "performed" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ ")" ]
                                             } ]
                                          } ]
                                       }, {
                                          "r" : "67",
                                          "value" : [ " ","overlaps"," " ]
                                       }, {
                                          "r" : "66",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n    )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "71",
               "locator" : "36:2-54:5",
               "type" : "Or",
               "operand" : [ {
                  "localId" : "55",
                  "locator" : "36:2-49:5",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "41",
                     "locator" : "36:2-44:2",
                     "type" : "Exists",
                     "operand" : {
                        "localId" : "40",
                        "locator" : "36:9-44:2",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "18",
                           "locator" : "37:5-37:55",
                           "alias" : "DischargeHospice",
                           "expression" : {
                              "localId" : "17",
                              "locator" : "37:5-37:38",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                              "codeProperty" : "type",
                              "type" : "Retrieve",
                              "codes" : {
                                 "locator" : "37:17-37:37",
                                 "name" : "Encounter Inpatient",
                                 "type" : "ValueSetRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "39",
                           "locator" : "38:4-43:64",
                           "type" : "And",
                           "operand" : [ {
                              "localId" : "34",
                              "locator" : "38:10-42:7",
                              "type" : "And",
                              "operand" : [ {
                                 "localId" : "22",
                                 "locator" : "38:10-38:45",
                                 "type" : "Equal",
                                 "operand" : [ {
                                    "name" : "ToString",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "20",
                                       "locator" : "38:10-38:32",
                                       "path" : "status",
                                       "scope" : "DischargeHospice",
                                       "type" : "Property"
                                    } ]
                                 }, {
                                    "localId" : "21",
                                    "locator" : "38:36-38:45",
                                    "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                    "value" : "finished",
                                    "type" : "Literal"
                                 } ]
                              }, {
                                 "localId" : "33",
                                 "locator" : "39:11-42:7",
                                 "type" : "Or",
                                 "operand" : [ {
                                    "localId" : "27",
                                    "locator" : "40:10-40:113",
                                    "type" : "Equivalent",
                                    "operand" : [ {
                                       "name" : "ToConcept",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "25",
                                          "locator" : "40:10-40:62",
                                          "path" : "dischargeDisposition",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "24",
                                             "locator" : "40:10-40:41",
                                             "path" : "hospitalization",
                                             "scope" : "DischargeHospice",
                                             "type" : "Property"
                                          }
                                       } ]
                                    }, {
                                       "type" : "ToConcept",
                                       "operand" : {
                                          "localId" : "26",
                                          "locator" : "40:66-40:113",
                                          "name" : "Discharge to home for hospice care (procedure)",
                                          "type" : "CodeRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "32",
                                    "locator" : "41:12-41:130",
                                    "type" : "Equivalent",
                                    "operand" : [ {
                                       "name" : "ToConcept",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "30",
                                          "locator" : "41:12-41:64",
                                          "path" : "dischargeDisposition",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "29",
                                             "locator" : "41:12-41:43",
                                             "path" : "hospitalization",
                                             "scope" : "DischargeHospice",
                                             "type" : "Property"
                                          }
                                       } ]
                                    }, {
                                       "type" : "ToConcept",
                                       "operand" : {
                                          "localId" : "31",
                                          "locator" : "41:68-41:130",
                                          "name" : "Discharge to healthcare facility for hospice care (procedure)",
                                          "type" : "CodeRef"
                                       }
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "localId" : "38",
                              "locator" : "43:9-43:64",
                              "type" : "In",
                              "operand" : [ {
                                 "locator" : "43:33-43:36",
                                 "type" : "End",
                                 "operand" : {
                                    "name" : "ToInterval",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "36",
                                       "locator" : "43:9-43:31",
                                       "path" : "period",
                                       "scope" : "DischargeHospice",
                                       "type" : "Property"
                                    } ]
                                 }
                              }, {
                                 "localId" : "37",
                                 "locator" : "43:45-43:64",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              } ]
                           } ]
                        }
                     }
                  }, {
                     "localId" : "54",
                     "locator" : "45:8-49:5",
                     "type" : "Exists",
                     "operand" : {
                        "localId" : "53",
                        "locator" : "45:15-49:5",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "43",
                           "locator" : "46:7-46:62",
                           "alias" : "HospiceOrder",
                           "expression" : {
                              "localId" : "42",
                              "locator" : "46:7-46:49",
                              "dataType" : "{http://hl7.org/fhir}ServiceRequest",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/ServiceRequest",
                              "codeProperty" : "code",
                              "type" : "Retrieve",
                              "codes" : {
                                 "locator" : "46:24-46:48",
                                 "name" : "Hospice care ambulatory",
                                 "type" : "ValueSetRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "52",
                           "locator" : "47:9-48:63",
                           "type" : "And",
                           "operand" : [ {
                              "localId" : "47",
                              "locator" : "47:15-47:43",
                              "type" : "Equal",
                              "operand" : [ {
                                 "name" : "ToString",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "45",
                                    "locator" : "47:15-47:33",
                                    "path" : "intent",
                                    "scope" : "HospiceOrder",
                                    "type" : "Property"
                                 } ]
                              }, {
                                 "localId" : "46",
                                 "locator" : "47:37-47:43",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                 "value" : "order",
                                 "type" : "Literal"
                              } ]
                           }, {
                              "localId" : "51",
                              "locator" : "48:17-48:63",
                              "type" : "In",
                              "operand" : [ {
                                 "name" : "ToDateTime",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "49",
                                    "locator" : "48:17-48:39",
                                    "path" : "authoredOn",
                                    "scope" : "HospiceOrder",
                                    "type" : "Property"
                                 } ]
                              }, {
                                 "localId" : "50",
                                 "locator" : "48:44-48:63",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              } ]
                           } ]
                        }
                     }
                  } ]
               }, {
                  "localId" : "70",
                  "locator" : "50:8-54:5",
                  "type" : "Exists",
                  "operand" : {
                     "localId" : "69",
                     "locator" : "50:15-54:5",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "57",
                        "locator" : "51:7-51:61",
                        "alias" : "HospicePerformed",
                        "expression" : {
                           "localId" : "56",
                           "locator" : "51:7-51:44",
                           "dataType" : "{http://hl7.org/fhir}Procedure",
                           "templateId" : "http://hl7.org/fhir/StructureDefinition/Procedure",
                           "codeProperty" : "code",
                           "type" : "Retrieve",
                           "codes" : {
                              "locator" : "51:19-51:43",
                              "name" : "Hospice care ambulatory",
                              "type" : "ValueSetRef"
                           }
                        }
                     } ],
                     "relationship" : [ ],
                     "where" : {
                        "localId" : "68",
                        "locator" : "52:9-53:99",
                        "type" : "And",
                        "operand" : [ {
                           "localId" : "61",
                           "locator" : "52:15-52:51",
                           "type" : "Equal",
                           "operand" : [ {
                              "name" : "ToString",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "59",
                                 "locator" : "52:15-52:37",
                                 "path" : "status",
                                 "scope" : "HospicePerformed",
                                 "type" : "Property"
                              } ]
                           }, {
                              "localId" : "60",
                              "locator" : "52:41-52:51",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "completed",
                              "type" : "Literal"
                           } ]
                        }, {
                           "localId" : "67",
                           "locator" : "53:15-53:99",
                           "type" : "Overlaps",
                           "operand" : [ {
                              "localId" : "65",
                              "locator" : "53:15-53:69",
                              "name" : "Normalize Interval",
                              "libraryName" : "Global",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "64",
                                 "locator" : "53:43-53:68",
                                 "path" : "performed",
                                 "scope" : "HospicePerformed",
                                 "type" : "Property"
                              } ]
                           }, {
                              "localId" : "66",
                              "locator" : "53:80-53:99",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           } ]
                        } ]
                     }
                  }
               } ]
            }
         } ]
      }
   }
}" + } ] + }, + "request": { + "method": "PUT", + "url": "Library/library-Hospice-2.0.000" + } + }, { + "resource": { + "resourceType": "MeasureReport", + "id": "measurereport-denom-EXM130", + "contained": [ { + "resourceType": "Bundle", + "id": "a1ff4631-43c9-4def-acc4-84afceb28d83", + "type": "collection", + "entry": [ { + "fullUrl": "823c4ee0-d1a8-447c-807d-96b89509b07a", + "resource": { + "resourceType": "List", + "id": "823c4ee0-d1a8-447c-807d-96b89509b07a", + "title": "initial-population", + "entry": [ { + "item": { + "reference": "denom-EXM130-1" + } + }, { + "item": { + "reference": "denom-EXM130" + } + } ] + } + }, { + "fullUrl": "Procedure/denom-EXM130-2", + "resource": { + "resourceType": "Procedure", + "id": "denom-EXM130-2", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" ] + }, + "status": "completed", + "code": { + "coding": [ { + "system": "http://www.ama-assn.org/go/cpt", + "code": "44393", + "display": "Colonoscopy through stoma; with ablation of tumor(s), polyp(s), or other lesion(s) not amenable to removal by hot biopsy forceps, bipolar cautery or snare technique" + } ] + }, + "subject": { + "reference": "Patient/denom-EXM130" + }, + "performedPeriod": { + "start": "2009-12-30T12:00:00", + "end": "2009-12-30T13:00:00" + } + } + }, { + "fullUrl": "Encounter/denom-EXM130-1", + "resource": { + "resourceType": "Encounter", + "id": "denom-EXM130-1", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" ] + }, + "status": "finished", + "class": { + "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode", + "code": "AMB", + "display": "ambulatory" + }, + "type": [ { + "coding": [ { + "system": "http://www.ama-assn.org/go/cpt", + "code": "99201", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: A problem focused history; A problem focused examination; Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are self limited or minor. Typically, 10 minutes are spent face-to-face with the patient and/or family." + } ] + } ], + "subject": { + "reference": "Patient/denom-EXM130" + }, + "period": { + "start": "2019-05-30T00:00:00-00:00", + "end": "2019-05-31T00:00:00-00:00" + } + } + }, { + "fullUrl": "9292a1f6-80bf-401b-a856-9fc4f66b1647", + "resource": { + "resourceType": "List", + "id": "9292a1f6-80bf-401b-a856-9fc4f66b1647", + "title": "numerator", + "entry": [ { + "item": { + "reference": "denom-EXM130-2" + } + } ] + } + }, { + "fullUrl": "Patient/denom-EXM130", + "resource": { + "resourceType": "Patient", + "id": "denom-EXM130", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, + "extension": [ { + "url": "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race", + "extension": [ { + "url": "ombCategory", + "valueCoding": { + "system": "urn:oid:2.16.840.1.113883.6.238", + "code": "2028-9", + "display": "Asian" + } + } ] + }, { + "url": "http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity", + "extension": [ { + "url": "ombCategory", + "valueCoding": { + "system": "urn:oid:2.16.840.1.113883.6.238", + "code": "2135-2", + "display": "Hispanic or Latino" + } + } ] + } ], + "identifier": [ { + "use": "usual", + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/v2-0203", + "code": "MR", + "display": "Medical Record Number" + } ] + }, + "system": "http://hospital.smarthealthit.org", + "value": "999999992" + } ], + "name": [ { + "family": "Dere", + "given": [ "Ben" ] + } ], + "gender": "male", + "birthDate": "1965-01-01" + } + } ] + } ], + "status": "complete", + "type": "individual", + "measure": "Measure/measure-EXM130-7.3.000", + "subject": { + "reference": "Patient/denom-EXM130" + }, + "period": { + "start": "2018-12-31T17:00:00-07:00", + "end": "2019-12-30T17:00:00-07:00" + }, + "group": [ { + "id": "group-1", + "population": [ { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } ] + }, + "count": 1 + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } ] + }, + "count": 0 + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } ] + }, + "count": 1 + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } ] + }, + "count": 0 + } ], + "measureScore": { + "value": 0.0 + } + } ], + "evaluatedResource": [ { + "reference": "#a1ff4631-43c9-4def-acc4-84afceb28d83" + } ] + }, + "request": { + "method": "PUT", + "url": "MeasureReport/measurereport-denom-EXM130" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.198.12.1019", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1019", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.198.12.1019" + } ], + "version": "20171222", + "name": "TotalColectomy", + "title": "Total Colectomy", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2006", + "concept": [ { + "code": "44152", + "display": "Colectomy, total, abdominal, without proctectomy; with rectal mucosectomy, ileoanal anastomosis, with or without loop ileostomy" + }, { + "code": "44153", + "display": "Colectomy, total, abdominal, without proctectomy; with rectal mucosectomy, ileoanal anastomosis, creation of ileal reservoir (S or J), with or without loop ileostomy" + } ] + }, { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2018", + "concept": [ { + "code": "44150", + "display": "Colectomy, total, abdominal, without proctectomy; with ileostomy or ileoproctostomy" + }, { + "code": "44151", + "display": "Colectomy, total, abdominal, without proctectomy; with continent ileostomy" + }, { + "code": "44155", + "display": "Colectomy, total, abdominal, with proctectomy; with ileostomy" + }, { + "code": "44156", + "display": "Colectomy, total, abdominal, with proctectomy; with continent ileostomy" + }, { + "code": "44157", + "display": "Colectomy, total, abdominal, with proctectomy; with ileoanal anastomosis, includes loop ileostomy, and rectal mucosectomy, when performed" + }, { + "code": "44158", + "display": "Colectomy, total, abdominal, with proctectomy; with ileoanal anastomosis, creation of ileal reservoir (S or J), includes loop ileostomy, and rectal mucosectomy, when performed" + }, { + "code": "44210", + "display": "Laparoscopy, surgical; colectomy, total, abdominal, without proctectomy, with ileostomy or ileoproctostomy" + }, { + "code": "44211", + "display": "Laparoscopy, surgical; colectomy, total, abdominal, with proctectomy, with ileoanal anastomosis, creation of ileal reservoir (S or J), with loop ileostomy, includes rectal mucosectomy, when performed" + }, { + "code": "44212", + "display": "Laparoscopy, surgical; colectomy, total, abdominal, with proctectomy, with ileostomy" + } ] + }, { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "26390003", + "display": "Total colectomy (procedure)" + }, { + "code": "303401008", + "display": "Parks panproctocolectomy, anastomosis of ileum to anus and creation of pouch (procedure)" + }, { + "code": "307666008", + "display": "Total colectomy and ileostomy (procedure)" + }, { + "code": "307667004", + "display": "Total colectomy, ileostomy and rectal mucous fistula (procedure)" + }, { + "code": "307669001", + "display": "Total colectomy, ileostomy and closure of rectal stump (procedure)" + }, { + "code": "31130001", + "display": "Total abdominal colectomy with proctectomy and ileostomy (procedure)" + }, { + "code": "36192008", + "display": "Total abdominal colectomy with ileoproctostomy (procedure)" + }, { + "code": "44751009", + "display": "Total abdominal colectomy with proctectomy and continent ileostomy (procedure)" + }, { + "code": "456004", + "display": "Total abdominal colectomy with ileostomy (procedure)" + }, { + "code": "80294005", + "display": "Total abdominal colectomy with rectal mucosectomy and ileoanal anastomosis (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.198.12.1019" + } + }, { + "resource": { + "resourceType": "Patient", + "id": "denom-EXM130", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, + "extension": [ { + "url": "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race", + "extension": [ { + "url": "ombCategory", + "valueCoding": { + "system": "urn:oid:2.16.840.1.113883.6.238", + "code": "2028-9", + "display": "Asian" + } + } ] + }, { + "url": "http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity", + "extension": [ { + "url": "ombCategory", + "valueCoding": { + "system": "urn:oid:2.16.840.1.113883.6.238", + "code": "2135-2", + "display": "Hispanic or Latino" + } + } ] + } ], + "identifier": [ { + "use": "usual", + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/v2-0203", + "code": "MR", + "display": "Medical Record Number" + } ] + }, + "system": "http://hospital.smarthealthit.org", + "value": "999999992" + } ], + "name": [ { + "family": "Dere", + "given": [ "Ben" ] + } ], + "gender": "male", + "birthDate": "1965-01-01" + }, + "request": { + "method": "PUT", + "url": "Patient/denom-EXM130" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.198.12.1010", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1010", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.198.12.1010" + } ], + "version": "20171219", + "name": "FlexibleSigmoidoscopy", + "title": "Flexible Sigmoidoscopy", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2014", + "concept": [ { + "code": "45339", + "display": "Sigmoidoscopy, flexible; with ablation of tumor(s), polyp(s), or other lesion(s) not amenable to removal by hot biopsy forceps, bipolar cautery or snare technique" + }, { + "code": "45345", + "display": "Sigmoidoscopy, flexible; with transendoscopic stent placement (includes predilation)" + } ] + }, { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2018", + "concept": [ { + "code": "45330", + "display": "Sigmoidoscopy, flexible; diagnostic, including collection of specimen(s) by brushing or washing, when performed (separate procedure)" + }, { + "code": "45331", + "display": "Sigmoidoscopy, flexible; with biopsy, single or multiple" + }, { + "code": "45332", + "display": "Sigmoidoscopy, flexible; with removal of foreign body(s)" + }, { + "code": "45333", + "display": "Sigmoidoscopy, flexible; with removal of tumor(s), polyp(s), or other lesion(s) by hot biopsy forceps" + }, { + "code": "45334", + "display": "Sigmoidoscopy, flexible; with control of bleeding, any method" + }, { + "code": "45335", + "display": "Sigmoidoscopy, flexible; with directed submucosal injection(s), any substance" + }, { + "code": "45337", + "display": "Sigmoidoscopy, flexible; with decompression (for pathologic distention) (eg, volvulus, megacolon), including placement of decompression tube, when performed" + }, { + "code": "45338", + "display": "Sigmoidoscopy, flexible; with removal of tumor(s), polyp(s), or other lesion(s) by snare technique" + }, { + "code": "45340", + "display": "Sigmoidoscopy, flexible; with transendoscopic balloon dilation" + }, { + "code": "45341", + "display": "Sigmoidoscopy, flexible; with endoscopic ultrasound examination" + }, { + "code": "45342", + "display": "Sigmoidoscopy, flexible; with transendoscopic ultrasound guided intramural or transmural fine needle aspiration/biopsy(s)" + }, { + "code": "45346", + "display": "Sigmoidoscopy, flexible; with ablation of tumor(s), polyp(s), or other lesion(s) (includes pre- and post-dilation and guide wire passage, when performed)" + }, { + "code": "45347", + "display": "Sigmoidoscopy, flexible; with placement of endoscopic stent (includes pre- and post-dilation and guide wire passage, when performed)" + }, { + "code": "45349", + "display": "Sigmoidoscopy, flexible; with endoscopic mucosal resection" + }, { + "code": "45350", + "display": "Sigmoidoscopy, flexible; with band ligation(s) (eg, hemorrhoids)" + } ] + }, { + "system": "https://www.cms.gov/Medicare/Coding/MedHCPCSGenInfo/index.html", + "version": "2018", + "concept": [ { + "code": "G0104", + "display": "Colorectal cancer screening; flexible sigmoidoscopy" + } ] + }, { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "396226005", + "display": "Flexible fiberoptic sigmoidoscopy with biopsy (procedure)" + }, { + "code": "425634007", + "display": "Diagnostic endoscopic examination of lower bowel and sampling for bacterial overgrowth using fiberoptic sigmoidoscope (procedure)" + }, { + "code": "44441009", + "display": "Flexible fiberoptic sigmoidoscopy (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.198.12.1010" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.198.12.1011", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1011", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.198.12.1011" + } ], + "version": "20171219", + "name": "FecalOccultBloodTest(FOBT)", + "title": "Fecal Occult Blood Test (FOBT)", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://loinc.org", + "version": "2.64", + "concept": [ { + "code": "12503-9", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool --4th specimen" + }, { + "code": "12504-7", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool --5th specimen" + }, { + "code": "14563-1", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool --1st specimen" + }, { + "code": "14564-9", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool --2nd specimen" + }, { + "code": "14565-6", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool --3rd specimen" + }, { + "code": "2335-8", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool" + }, { + "code": "27396-1", + "display": "Hemoglobin.gastrointestinal [Mass/mass] in Stool" + }, { + "code": "27401-9", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool --6th specimen" + }, { + "code": "27925-7", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool --7th specimen" + }, { + "code": "27926-5", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool --8th specimen" + }, { + "code": "29771-3", + "display": "Hemoglobin.gastrointestinal.lower [Presence] in Stool by Immunoassay" + }, { + "code": "56490-6", + "display": "Hemoglobin.gastrointestinal.lower [Presence] in Stool by Immunoassay --2nd specimen" + }, { + "code": "56491-4", + "display": "Hemoglobin.gastrointestinal.lower [Presence] in Stool by Immunoassay --3rd specimen" + }, { + "code": "57905-2", + "display": "Hemoglobin.gastrointestinal.lower [Presence] in Stool by Immunoassay --1st specimen" + }, { + "code": "58453-2", + "display": "Hemoglobin.gastrointestinal.lower [Mass/volume] in Stool by Immunoassay" + }, { + "code": "80372-6", + "display": "Hemoglobin.gastrointestinal [Presence] in Stool by Rapid immunoassay" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.198.12.1011" + } + }, { + "resource": { + "resourceType": "Procedure", + "id": "denom-EXM130-2", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" ] + }, + "status": "completed", + "code": { + "coding": [ { + "system": "http://www.ama-assn.org/go/cpt", + "code": "44393", + "display": "Colonoscopy through stoma; with ablation of tumor(s), polyp(s), or other lesion(s) not amenable to removal by hot biopsy forceps, bipolar cautery or snare technique" + } ] + }, + "subject": { + "reference": "Patient/denom-EXM130" + }, + "performedPeriod": { + "start": "2009-12-30T12:00:00", + "end": "2009-12-30T13:00:00" + } + }, + "request": { + "method": "PUT", + "url": "Procedure/denom-EXM130-2" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.101.12.1025", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.101.12.1025" + } ], + "version": "20170504", + "name": "PreventiveCareServices-EstablishedOfficeVisit,18andUp", + "title": "Preventive Care Services - Established Office Visit, 18 and Up", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2018", + "concept": [ { + "code": "99395", + "display": "Periodic comprehensive preventive medicine reevaluation and management of an individual including an age and gender appropriate history, examination, counseling/anticipatory guidance/risk factor reduction interventions, and the ordering of laboratory/diagnostic procedures, established patient; 18-39 years" + }, { + "code": "99396", + "display": "Periodic comprehensive preventive medicine reevaluation and management of an individual including an age and gender appropriate history, examination, counseling/anticipatory guidance/risk factor reduction interventions, and the ordering of laboratory/diagnostic procedures, established patient; 40-64 years" + }, { + "code": "99397", + "display": "Periodic comprehensive preventive medicine reevaluation and management of an individual including an age and gender appropriate history, examination, counseling/anticipatory guidance/risk factor reduction interventions, and the ordering of laboratory/diagnostic procedures, established patient; 65 years and older" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.101.12.1001", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.101.12.1001" + } ], + "version": "20180310", + "name": "OfficeVisit", + "title": "Office Visit", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2018", + "concept": [ { + "code": "99201", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: A problem focused history; A problem focused examination; Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are self limited or minor. Typically, 10 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99202", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: An expanded problem focused history; An expanded problem focused examination; Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of low to moderate severity. Typically, 20 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99203", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: A detailed history; A detailed examination; Medical decision making of low complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of moderate severity. Typically, 30 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99204", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: A comprehensive history; A comprehensive examination; Medical decision making of moderate complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of moderate to high severity. Typically, 45 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99205", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: A comprehensive history; A comprehensive examination; Medical decision making of high complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of moderate to high severity. Typically, 60 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99212", + "display": "Office or other outpatient visit for the evaluation and management of an established patient, which requires at least 2 of these 3 key components: A problem focused history; A problem focused examination; Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are self limited or minor. Typically, 10 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99213", + "display": "Office or other outpatient visit for the evaluation and management of an established patient, which requires at least 2 of these 3 key components: An expanded problem focused history; An expanded problem focused examination; Medical decision making of low complexity. Counseling and coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of low to moderate severity. Typically, 15 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99214", + "display": "Office or other outpatient visit for the evaluation and management of an established patient, which requires at least 2 of these 3 key components: A detailed history; A detailed examination; Medical decision making of moderate complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of moderate to high severity. Typically, 25 minutes are spent face-to-face with the patient and/or family." + }, { + "code": "99215", + "display": "Office or other outpatient visit for the evaluation and management of an established patient, which requires at least 2 of these 3 key components: A comprehensive history; A comprehensive examination; Medical decision making of high complexity. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are of moderate to high severity. Typically, 40 minutes are spent face-to-face with the patient and/or family." + } ] + }, { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "185463005", + "display": "Visit out of hours (procedure)" + }, { + "code": "185464004", + "display": "Out of hours visit - not night visit (procedure)" + }, { + "code": "185465003", + "display": "Weekend visit (procedure)" + }, { + "code": "30346009", + "display": "Evaluation and management of established outpatient in office or other outpatient facility (procedure)" + }, { + "code": "3391000175108", + "display": "Office visit for pediatric care and assessment (procedure)" + }, { + "code": "37894004", + "display": "Evaluation and management of new outpatient in office or other outpatient facility (procedure)" + }, { + "code": "439740005", + "display": "Postoperative follow-up visit (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.101.12.1023", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.101.12.1023" + } ], + "version": "20170504", + "name": "PreventiveCareServices-InitialOfficeVisit,18andUp", + "title": "Preventive Care Services-Initial Office Visit, 18 and Up", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2018", + "concept": [ { + "code": "99385", + "display": "Initial comprehensive preventive medicine evaluation and management of an individual including an age and gender appropriate history, examination, counseling/anticipatory guidance/risk factor reduction interventions, and the ordering of laboratory/diagnostic procedures, new patient; 18-39 years" + }, { + "code": "99386", + "display": "Initial comprehensive preventive medicine evaluation and management of an individual including an age and gender appropriate history, examination, counseling/anticipatory guidance/risk factor reduction interventions, and the ordering of laboratory/diagnostic procedures, new patient; 40-64 years" + }, { + "code": "99387", + "display": "Initial comprehensive preventive medicine evaluation and management of an individual including an age and gender appropriate history, examination, counseling/anticipatory guidance/risk factor reduction interventions, and the ordering of laboratory/diagnostic procedures, new patient; 65 years and older" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + }, { + "resource": { + "resourceType": "Measure", + "id": "measure-EXM130-7.3.000", + "meta": { + "profile": [ "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/proportion-measure-cqfm" ] + }, + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-populationBasis", + "valueCode": "boolean" + }, { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "#cqf-tooling" + } + } ], + "url": "http://hl7.org/fhir/us/cqfmeasures/Measure/EXM130", + "identifier": [ { + "use": "official", + "system": "http://hl7.org/fhir/cqi/ecqm/Measure/Identifier/cms", + "value": "130" + }, { + "use": "official", + "system": "http://hl7.org/fhir/cqi/ecqm/Measure/Identifier/nqf", + "value": "0034" + } ], + "version": "7.3.000", + "name": "EXM130", + "title": "Colorectal Cancer Screening", + "status": "active", + "experimental": true, + "date": "2018-08-28", + "publisher": "National Committee for Quality Assurance", + "contact": [ { + "telecom": [ { + "system": "url", + "value": "http://www.ncqa.org/" + } ] + } ], + "description": "Percentage of adults 50-75 years of age who had appropriate screening for colorectal cancer", + "useContext": [ { + "code": { + "code": "program" + }, + "valueCodeableConcept": { + "text": "eligible-provider" + } + } ], + "jurisdiction": [ { + "coding": [ { + "system": "urn:iso:std:iso:3166", + "code": "US" + } ] + } ], + "purpose": "Patients 50-75 years of age with a visit during the measurement period", + "copyright": "This Physician Performance Measure (Measure) and related data specifications were developed by the National Committee for Quality Assurance (NCQA). NCQA is not responsible for any use of the Measure. NCQA makes no representations, warranties, or endorsement about the quality of any organization or physician that uses or reports performance measures and NCQA has no liability to anyone who relies on such measures or specifications. NCQA holds a copyright in the Measure. The Measure can be reproduced and distributed, without modification, for noncommercial purposes (eg, use by healthcare providers in connection with their practices) without obtaining approval from NCQA. Commercial use is defined as the sale, licensing, or distribution of the Measure for commercial gain, or incorporation of the Measure into a product or service that is sold, licensed or distributed for commercial gain. All commercial uses or requests for modification must be approved by NCQA and are subject to a license at the discretion of NCQA. (C) 2012-2017 National Committee for Quality Assurance. All Rights Reserved. Limited proprietary coding is contained in the Measure specifications for user convenience. Users of proprietary code sets should obtain all necessary licenses from the owners of the code sets. NCQA disclaims all liability for use or accuracy of any third party codes contained in the specifications. CPT(R) contained in the Measure specifications is copyright 2004-2017 American Medical Association. LOINC(R) copyright 2004-2017 Regenstrief Institute, Inc. This material contains SNOMED Clinical Terms(R) (SNOMED CT[R] ) copyright 2004-2017 International Health Terminology Standards Development Organisation. ICD-10 copyright 2017 World Health Organization. All Rights Reserved.", + "approvalDate": "2016-01-01", + "lastReviewDate": "2016-09-01", + "effectivePeriod": { + "start": "2018-01-01", + "end": "2018-12-31" + }, + "topic": [ { + "coding": [ { + "system": "http://loinc.org", + "code": "57024-2", + "display": "Health Quality Measure Document" + } ] + } ], + "relatedArtifact": [ { + "type": "citation", + "citation": "U.S. Preventive Services Task Force. \"Screening for Colorectal Cancer: U.S. Preventive Services Task Force Recommendation Statement.\" JAMA, vol. 315, no. 23, 2016, pp. 2564-2575. doi: 10.1001/jama.2016.5989" + }, { + "type": "citation", + "citation": "Howlader, N., A.M. Noone, M. Krapcho, D. Miller, K. Bishop, C.L. Kosary, M. Yu, J. Ruhl, Z. Tatalovich, A. Mariotto, D.R. Lewis, H.S. Chen, E.J. Feuer, and K.A. Cronin. \"SEER Cancer Statistics Review, 1975-2014.\" Washington, DC: National Cancer Institute, 2017. Available at https://seer.cancer.gov/csr/1975_2014/" + }, { + "type": "citation", + "citation": "American Cancer Society. \"Can Colorectal Polyps and Cancer Be Found Early?\" Last modified March 2017. Washington, DC: American Cancer Society. Available at https://www.cancer.org/cancer/colon-rectal-cancer/detection-diagnosis-staging/detection.html." + }, { + "type": "depends-on", + "resource": "Library/library-FHIRHelpers-4.0.1" + }, { + "type": "depends-on", + "resource": "Library/library-Hospice-2.0.000" + }, { + "type": "depends-on", + "resource": "Library/library-AdultOutpatientEncounters-2.0.000" + }, { + "type": "depends-on", + "resource": "Library/library-MATGlobalCommonFunctions-5.0.000" + }, { + "type": "depends-on", + "resource": "Library/library-SupplementalDataElements-2.0.0" + } ], + "library": [ "Library/library-EXM130-7.3.000" ], + "disclaimer": "The performance Measure is not a clinical guideline and does not establish a standard of medical care, and has not been tested for all potential applications. THE MEASURE AND SPECIFICATIONS ARE PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. Due to technical limitations, registered trademarks are indicated by (R) or [R] and unregistered trademarks are indicated by (TM) or [TM].", + "scoring": { + "coding": [ { + "system": "http://hl7.org/fhir/measure-scoring", + "code": "proportion" + } ] + }, + "type": [ { + "coding": [ { + "system": "http://hl7.org/fhir/measure-type", + "code": "process" + } ] + } ], + "rationale": "Colorectal cancer represents 8 percent of all new cancer cases and is the second leading cause of cancer deaths in the United States. In 2017, there were an estimated 135,430 new cases of colorectal cancer and an estimated 50,260 deaths attributed to it. According to the National Cancer Institute, about 4.3 percent of men and women will be diagnosed with colorectal cancer at some point during their lifetimes. For most adults, older age is the most important risk factor for colorectal cancer, although being male and black are also associated with higher incidence and mortality. Colorectal cancer is most frequently diagnosed among people 65 to 74 years old (Howlader et al. 2017). Screening can be effective for finding precancerous lesions (polyps) that could later become malignant, and for detecting early cancers that can be more easily and effectively treated. Precancerous polyps usually take about 10 to 15 years to develop into colorectal cancer, and most can be found and removed before turning into cancer. The five-year relative survival rate for people whose colorectal cancer is found in the early stage before it has spread is about 90 percent (American Cancer Society 2017).", + "clinicalRecommendationStatement": "The U. S. Preventive Services Task Force (2016) recommends screening for colorectal cancer starting at age 50 years and continuing until age 75 years. This is a Grade A recommendation (U.S. Preventive Services Task Force 2016). Screening tests: -Colonoscopy (every 10 years) -Flexible sigmoidoscopy (every 5 years) -Fecal occult blood test (annually) -FIT-DNA (every 3 years) -Computed tomographic colonography (every 5 years)", + "improvementNotation": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-improvement-notation", + "code": "increase" + } ] + }, + "guidance": "Patient self-report for procedures as well as diagnostic studies should be recorded in \"Procedure, Performed\" template or \"Diagnostic Study, Performed\" template in QRDA-1. Do not count DRE, FOBT tests performed in an office setting or performed on a sample collected via DRE.", + "group": [ { + "id": "group-1", + "population": [ { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } ] + }, + "criteria": { + "language": "text/cql", + "expression": "Initial Population" + } + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } ] + }, + "criteria": { + "language": "text/cql", + "expression": "Numerator" + } + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } ] + }, + "criteria": { + "language": "text/cql", + "expression": "Denominator" + } + }, { + "code": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } ] + }, + "criteria": { + "language": "text/cql", + "expression": "Denominator Exclusion" + } + } ] + } ], + "supplementalData": [ { + "code": { + "text": "sde-ethnicity" + }, + "usage": [ { + "coding": [ { + "system": "http://hl7.org/fhir/measure-data-usage", + "code": "supplemental-data" + } ] + } ], + "criteria": { + "language": "text/cql", + "expression": "SDE Ethnicity" + } + }, { + "code": { + "text": "sde-payer" + }, + "usage": [ { + "coding": [ { + "system": "http://hl7.org/fhir/measure-data-usage", + "code": "supplemental-data" + } ] + } ], + "criteria": { + "language": "text/cql", + "expression": "SDE Payer" + } + }, { + "code": { + "text": "sde-race" + }, + "usage": [ { + "coding": [ { + "system": "http://hl7.org/fhir/measure-data-usage", + "code": "supplemental-data" + } ] + } ], + "criteria": { + "language": "text/cql", + "expression": "SDE Race" + } + }, { + "code": { + "text": "sde-sex" + }, + "usage": [ { + "coding": [ { + "system": "http://hl7.org/fhir/measure-data-usage", + "code": "supplemental-data" + } ] + } ], + "criteria": { + "language": "text/cql", + "expression": "SDE Sex" + } + } ] + }, + "request": { + "method": "PUT", + "url": "Measure/measure-EXM130-7.3.000" + } + }, { + "resource": { + "resourceType": "Encounter", + "id": "denom-EXM130-1", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" ] + }, + "status": "finished", + "class": { + "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode", + "code": "AMB", + "display": "ambulatory" + }, + "type": [ { + "coding": [ { + "system": "http://www.ama-assn.org/go/cpt", + "code": "99201", + "display": "Office or other outpatient visit for the evaluation and management of a new patient, which requires these 3 key components: A problem focused history; A problem focused examination; Straightforward medical decision making. Counseling and/or coordination of care with other physicians, other qualified health care professionals, or agencies are provided consistent with the nature of the problem(s) and the patient's and/or family's needs. Usually, the presenting problem(s) are self limited or minor. Typically, 10 minutes are spent face-to-face with the patient and/or family." + } ] + } ], + "subject": { + "reference": "Patient/denom-EXM130" + }, + "period": { + "start": "2019-05-30T00:00:00-00:00", + "end": "2019-05-31T00:00:00-00:00" + } + }, + "request": { + "method": "PUT", + "url": "Encounter/denom-EXM130-1" + } + }, { + "resource": { + "resourceType": "Library", + "id": "library-EXM130-7.3.000", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "#cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/dbcg/connectathon/Library/EXM130", + "version": "7.3.000", + "name": "EXM130", + "status": "active", + "experimental": true, + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } ] + }, + "relatedArtifact": [ { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIRHelpers|4.0.1" + }, { + "type": "depends-on", + "resource": "http://fhir.org/guides/dbcg/connectathon/Library/Hospice|2.0.000" + }, { + "type": "depends-on", + "resource": "http://fhir.org/guides/dbcg/connectathon/Library/AdultOutpatientEncounters|2.0.000" + }, { + "type": "depends-on", + "resource": "http://fhir.org/guides/dbcg/connectathon/Library/MATGlobalCommonFunctions|5.0.000" + }, { + "type": "depends-on", + "resource": "http://fhir.org/guides/dbcg/connectathon/Library/SupplementalDataElements|2.0.0" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.836" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.837" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1020" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1011" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1010" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1001" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1019" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1039" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1038" + } ], + "parameter": [ { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Patient" + }, { + "name": "SDE Ethnicity", + "use": "out", + "min": 0, + "max": "*", + "type": "Coding" + }, { + "name": "SDE Payer", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "SDE Race", + "use": "out", + "min": 0, + "max": "*", + "type": "Coding" + }, { + "name": "SDE Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + }, { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, { + "name": "Flexible Sigmoidoscopy Performed", + "use": "out", + "min": 0, + "max": "*", + "type": "Procedure" + }, { + "name": "CT Colonography Performed", + "use": "out", + "min": 0, + "max": "*", + "type": "Procedure" + }, { + "name": "Total Colectomy Performed", + "use": "out", + "min": 0, + "max": "*", + "type": "Procedure" + }, { + "name": "Malignant Neoplasm Ever", + "use": "out", + "min": 0, + "max": "*", + "type": "Condition" + }, { + "name": "Fecal Occult Blood Test Performed", + "use": "out", + "min": 0, + "max": "*", + "type": "Observation" + }, { + "name": "Fecal Immunochemical Test DNA", + "use": "out", + "min": 0, + "max": "*", + "type": "Observation" + }, { + "name": "Colonoscopy Performed", + "use": "out", + "min": 0, + "max": "*", + "type": "Procedure" + }, { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, { + "name": "Denominator Exclusion", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + } ], + "dataRequirement": [ { + "type": "Procedure", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Procedure" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1010" + } ] + }, { + "type": "Procedure", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Procedure" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1038" + } ] + }, { + "type": "Procedure", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Procedure" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1019" + } ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1001" + } ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Observation" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1011" + } ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Observation" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1039" + } ] + }, { + "type": "Procedure", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Procedure" ], + "codeFilter": [ { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1020" + } ] + } ], + "content": [ { + "contentType": "text/cql", + "data": "bGlicmFyeSBFWE0xMzAgdmVyc2lvbiAnNy4zLjAwMCcNCg0KLyoNCkJhc2VkIG9uIENNUzEzMHY3IC0gQ29sb3JlY3RhbCBDYW5jZXIgU2NyZWVuaW5nDQoqLw0KDQovKg0KVGhpcyBleGFtcGxlIGlzIGEgd29yayBpbiBwcm9ncmVzcyBhbmQgc2hvdWxkIG5vdCBiZSBjb25zaWRlcmVkIGEgZmluYWwgc3BlY2lmaWNhdGlvbg0Kb3IgcmVjb21tZW5kYXRpb24gZm9yIGd1aWRhbmNlLiBUaGlzIGV4YW1wbGUgd2lsbCBoZWxwIGd1aWRlIGFuZCBkaXJlY3QgdGhlIHByb2Nlc3MNCm9mIGZpbmRpbmcgY29udmVudGlvbnMgYW5kIHVzYWdlIHBhdHRlcm5zIHRoYXQgbWVldCB0aGUgbmVlZHMgb2YgdGhlIHZhcmlvdXMgc3Rha2Vob2xkZXJzDQppbiB0aGUgbWVhc3VyZSBkZXZlbG9wbWVudCBjb21tdW5pdHkuDQoqLw0KDQp1c2luZyBGSElSIHZlcnNpb24gJzQuMC4xJw0KDQppbmNsdWRlIEZISVJIZWxwZXJzIHZlcnNpb24gJzQuMC4xJyBjYWxsZWQgRkhJUkhlbHBlcnMNCmluY2x1ZGUgSG9zcGljZSB2ZXJzaW9uICcyLjAuMDAwJyBjYWxsZWQgSG9zcGljZQ0KaW5jbHVkZSBBZHVsdE91dHBhdGllbnRFbmNvdW50ZXJzIHZlcnNpb24gJzIuMC4wMDAnIGNhbGxlZCBBZHVsdE91dHBhdGllbnRFbmNvdW50ZXJzDQppbmNsdWRlIE1BVEdsb2JhbENvbW1vbkZ1bmN0aW9ucyB2ZXJzaW9uICc1LjAuMDAwJyBjYWxsZWQgR2xvYmFsDQppbmNsdWRlIFN1cHBsZW1lbnRhbERhdGFFbGVtZW50cyB2ZXJzaW9uICcyLjAuMCcgY2FsbGVkIFNERQ0KDQp2YWx1ZXNldCAiT05DIEFkbWluaXN0cmF0aXZlIFNleCI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTM3NjIuMS40LjEnDQp2YWx1ZXNldCAiUmFjZSI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTQyMjIuNC4xMS44MzYnDQp2YWx1ZXNldCAiRXRobmljaXR5IjogJ2h0dHA6Ly9jdHMubmxtLm5paC5nb3YvZmhpci9WYWx1ZVNldC8yLjE2Ljg0MC4xLjExNDIyMi40LjExLjgzNycNCnZhbHVlc2V0ICJQYXllciI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTQyMjIuNC4xMS4zNTkxJw0KdmFsdWVzZXQgIkNvbG9ub3Njb3B5IjogJ2h0dHA6Ly9jdHMubmxtLm5paC5nb3YvZmhpci9WYWx1ZVNldC8yLjE2Ljg0MC4xLjExMzg4My4zLjQ2NC4xMDAzLjEwOC4xMi4xMDIwJw0KdmFsdWVzZXQgIkZlY2FsIE9jY3VsdCBCbG9vZCBUZXN0IChGT0JUKSI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTM4ODMuMy40NjQuMTAwMy4xOTguMTIuMTAxMScNCnZhbHVlc2V0ICJGbGV4aWJsZSBTaWdtb2lkb3Njb3B5IjogJ2h0dHA6Ly9jdHMubmxtLm5paC5nb3YvZmhpci9WYWx1ZVNldC8yLjE2Ljg0MC4xLjExMzg4My4zLjQ2NC4xMDAzLjE5OC4xMi4xMDEwJw0KdmFsdWVzZXQgIk1hbGlnbmFudCBOZW9wbGFzbSBvZiBDb2xvbiI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTM4ODMuMy40NjQuMTAwMy4xMDguMTIuMTAwMScNCnZhbHVlc2V0ICJUb3RhbCBDb2xlY3RvbXkiOiAnaHR0cDovL2N0cy5ubG0ubmloLmdvdi9maGlyL1ZhbHVlU2V0LzIuMTYuODQwLjEuMTEzODgzLjMuNDY0LjEwMDMuMTk4LjEyLjEwMTknDQp2YWx1ZXNldCAiRklUIEROQSI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTM4ODMuMy40NjQuMTAwMy4xMDguMTIuMTAzOScNCnZhbHVlc2V0ICJDVCBDb2xvbm9ncmFwaHkiOiAnaHR0cDovL2N0cy5ubG0ubmloLmdvdi9maGlyL1ZhbHVlU2V0LzIuMTYuODQwLjEuMTEzODgzLjMuNDY0LjEwMDMuMTA4LjEyLjEwMzgnDQoNCnBhcmFtZXRlciAiTWVhc3VyZW1lbnQgUGVyaW9kIiBJbnRlcnZhbDxEYXRlVGltZT4NCiAgZGVmYXVsdCBJbnRlcnZhbFtAMjAxOS0wMS0wMVQwMDowMDowMC4wLCBAMjAyMC0wMS0wMVQwMDowMDowMC4wKQ0KDQpjb250ZXh0IFBhdGllbnQNCg0KZGVmaW5lICJTREUgRXRobmljaXR5IjoNCiAgU0RFLiJTREUgRXRobmljaXR5Ig0KDQpkZWZpbmUgIlNERSBQYXllciI6DQogIFNERS4iU0RFIFBheWVyIg0KDQpkZWZpbmUgIlNERSBSYWNlIjoNCiAgU0RFLiJTREUgUmFjZSINCg0KZGVmaW5lICJTREUgU2V4IjoNCiAgU0RFLiJTREUgU2V4Ig0KDQpkZWZpbmUgIkRlbm9taW5hdG9yIjoNCgl0cnVlDQoNCmRlZmluZSAiRmxleGlibGUgU2lnbW9pZG9zY29weSBQZXJmb3JtZWQiOg0KCVtQcm9jZWR1cmU6ICJGbGV4aWJsZSBTaWdtb2lkb3Njb3B5Il0gRmxleGlibGVTaWdtb2lkb3Njb3B5DQoJCXdoZXJlIEZsZXhpYmxlU2lnbW9pZG9zY29weS5zdGF0dXMgPSAnY29tcGxldGVkJw0KCQkJYW5kIEdsb2JhbC4iTm9ybWFsaXplIEludGVydmFsIihGbGV4aWJsZVNpZ21vaWRvc2NvcHkucGVyZm9ybWVkKSBlbmRzIDUgeWVhcnMgb3IgbGVzcyBvbiBvciBiZWZvcmUgZW5kIG9mICJNZWFzdXJlbWVudCBQZXJpb2QiDQoNCmRlZmluZSAiQ1QgQ29sb25vZ3JhcGh5IFBlcmZvcm1lZCI6DQoJW1Byb2NlZHVyZTogIkNUIENvbG9ub2dyYXBoeSJdIENvbG9ub2dyYXBoeQ0KCQl3aGVyZSBDb2xvbm9ncmFwaHkuc3RhdHVzID0gJ2NvbXBsZXRlZCcNCgkJCWFuZCBHbG9iYWwuIk5vcm1hbGl6ZSBJbnRlcnZhbCIoQ29sb25vZ3JhcGh5LnBlcmZvcm1lZCkgZW5kcyA1IHllYXJzIG9yIGxlc3Mgb24gb3IgYmVmb3JlIGVuZCBvZiAiTWVhc3VyZW1lbnQgUGVyaW9kIg0KDQpkZWZpbmUgIlRvdGFsIENvbGVjdG9teSBQZXJmb3JtZWQiOg0KCVtQcm9jZWR1cmU6ICJUb3RhbCBDb2xlY3RvbXkiXSBDb2xlY3RvbXkNCgkJd2hlcmUgQ29sZWN0b215LnN0YXR1cyA9ICdjb21wbGV0ZWQnDQoJCQlhbmQgR2xvYmFsLiJOb3JtYWxpemUgSW50ZXJ2YWwiKENvbGVjdG9teS5wZXJmb3JtZWQpIHN0YXJ0cyBvbiBvciBiZWZvcmUgZW5kIG9mICJNZWFzdXJlbWVudCBQZXJpb2QiDQoNCmRlZmluZSAiTWFsaWduYW50IE5lb3BsYXNtIEV2ZXIiOg0KCVtDb25kaXRpb246ICJNYWxpZ25hbnQgTmVvcGxhc20gb2YgQ29sb24iXSBDb2xvcmVjdGFsQ2FuY2VyDQoJCXdoZXJlIEdsb2JhbC4iTm9ybWFsaXplIEludGVydmFsIihDb2xvcmVjdGFsQ2FuY2VyLm9uc2V0KSBzdGFydHMgb24gb3IgYmVmb3JlIGVuZCBvZiAiTWVhc3VyZW1lbnQgUGVyaW9kIg0KDQpkZWZpbmUgIkZlY2FsIE9jY3VsdCBCbG9vZCBUZXN0IFBlcmZvcm1lZCI6DQoJW09ic2VydmF0aW9uOiAiRmVjYWwgT2NjdWx0IEJsb29kIFRlc3QgKEZPQlQpIl0gRmVjYWxPY2N1bHRSZXN1bHQNCgkJd2hlcmUgRmVjYWxPY2N1bHRSZXN1bHQuc3RhdHVzIGluIHsnZmluYWwnLCAnYW1lbmRlZCcsICdjb3JyZWN0ZWQnLCAncHJlbGltaW5hcnknfQ0KCQkJYW5kIEZlY2FsT2NjdWx0UmVzdWx0LnZhbHVlIGlzIG5vdCBudWxsDQoJCQlhbmQgR2xvYmFsLiJOb3JtYWxpemUgSW50ZXJ2YWwiKEZlY2FsT2NjdWx0UmVzdWx0LmVmZmVjdGl2ZSkgZHVyaW5nIGRheSBvZiAiTWVhc3VyZW1lbnQgUGVyaW9kIg0KDQpkZWZpbmUgIkZlY2FsIEltbXVub2NoZW1pY2FsIFRlc3QgRE5BIjoNCglbT2JzZXJ2YXRpb246ICJGSVQgRE5BIl0gRml0RE5BDQoJCXdoZXJlIEZpdEROQS5zdGF0dXMgaW4geydmaW5hbCcsICdhbWVuZGVkJywgJ2NvcnJlY3RlZCcsICdwcmVsaW1pbmFyeSd9DQoJCQlhbmQgRml0RE5BLnZhbHVlIGlzIG5vdCBudWxsDQoJCQlhbmQgR2xvYmFsLiJOb3JtYWxpemUgSW50ZXJ2YWwiKEZpdEROQS5lZmZlY3RpdmUpIG9jY3VycyAzIHllYXJzIG9yIGxlc3Mgb24gb3IgYmVmb3JlIGRheSBvZiBlbmQgb2YgIk1lYXN1cmVtZW50IFBlcmlvZCINCg0KZGVmaW5lICJDb2xvbm9zY29weSBQZXJmb3JtZWQiOg0KCVtQcm9jZWR1cmU6ICJDb2xvbm9zY29weSJdIENvbG9ub3Njb3B5DQoJCXdoZXJlIENvbG9ub3Njb3B5LnN0YXR1cyA9ICdjb21wbGV0ZWQnDQoJCSAgYW5kIEdsb2JhbC4iTm9ybWFsaXplIEludGVydmFsIihDb2xvbm9zY29weS5wZXJmb3JtZWQpIGVuZHMgMTAgeWVhcnMgb3IgbGVzcyBvbiBvciBiZWZvcmUgZW5kIG9mICJNZWFzdXJlbWVudCBQZXJpb2QiDQoNCmRlZmluZSAiTnVtZXJhdG9yIjoNCglleGlzdHMgIkNvbG9ub3Njb3B5IFBlcmZvcm1lZCINCgkJb3IgZXhpc3RzICJGZWNhbCBPY2N1bHQgQmxvb2QgVGVzdCBQZXJmb3JtZWQiDQoJCW9yIGV4aXN0cyAiRmxleGlibGUgU2lnbW9pZG9zY29weSBQZXJmb3JtZWQiDQoJCW9yIGV4aXN0cyAiRmVjYWwgSW1tdW5vY2hlbWljYWwgVGVzdCBETkEiDQoJCW9yIGV4aXN0cyAiQ1QgQ29sb25vZ3JhcGh5IFBlcmZvcm1lZCINCg0KZGVmaW5lICJEZW5vbWluYXRvciBFeGNsdXNpb24iOg0KCUhvc3BpY2UuIkhhcyBIb3NwaWNlIg0KCQlvciBleGlzdHMgIk1hbGlnbmFudCBOZW9wbGFzbSBFdmVyIg0KCQlvciBleGlzdHMgIlRvdGFsIENvbGVjdG9teSBQZXJmb3JtZWQiDQoNCmRlZmluZSAiSW5pdGlhbCBQb3B1bGF0aW9uIjoNCglHbG9iYWwuIkNhbGVuZGFyQWdlSW5ZZWFyc0F0IihGSElSSGVscGVycy5Ub0RhdGUoUGF0aWVudC5iaXJ0aERhdGUpLCBzdGFydCBvZiAiTWVhc3VyZW1lbnQgUGVyaW9kIikgaW4gSW50ZXJ2YWxbNTAsIDc1XQ0KCQkJYW5kIGV4aXN0cyBBZHVsdE91dHBhdGllbnRFbmNvdW50ZXJzLiJRdWFsaWZ5aW5nIEVuY291bnRlcnMiDQo=" + }, { + "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="1.3" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <identifier id="EXM130" system="http://fhir.org/guides/dbcg/connectathon" version="7.3.000"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="14:1-14:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1"/>
   </usings>
   <includes>
      <def localId="2" locator="16:1-16:54" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/dbcg/connectathon/FHIRHelpers" version="4.0.1"/>
      <def localId="3" locator="17:1-17:48" localIdentifier="Hospice" path="http://fhir.org/guides/dbcg/connectathon/Hospice" version="2.0.000"/>
      <def localId="4" locator="18:1-18:84" localIdentifier="AdultOutpatientEncounters" path="http://fhir.org/guides/dbcg/connectathon/AdultOutpatientEncounters" version="2.0.000"/>
      <def localId="5" locator="19:1-19:64" localIdentifier="Global" path="http://fhir.org/guides/dbcg/connectathon/MATGlobalCommonFunctions" version="5.0.000"/>
      <def localId="6" locator="20:1-20:59" localIdentifier="SDE" path="http://fhir.org/guides/dbcg/connectathon/SupplementalDataElements" version="2.0.0"/>
   </includes>
   <parameters>
      <def localId="23" locator="34:1-35:66" name="Measurement Period" accessLevel="Public">
         <default localId="20" locator="35:11-35:66" lowClosed="true" highClosed="false" xsi:type="Interval">
            <low localId="18" locator="35:20-35:41" xsi:type="DateTime">
               <year valueType="t:Integer" value="2019" xsi:type="Literal"/>
               <month valueType="t:Integer" value="1" xsi:type="Literal"/>
               <day valueType="t:Integer" value="1" xsi:type="Literal"/>
               <hour valueType="t:Integer" value="0" xsi:type="Literal"/>
               <minute valueType="t:Integer" value="0" xsi:type="Literal"/>
               <second valueType="t:Integer" value="0" xsi:type="Literal"/>
               <millisecond valueType="t:Integer" value="0" xsi:type="Literal"/>
            </low>
            <high localId="19" locator="35:44-35:65" xsi:type="DateTime">
               <year valueType="t:Integer" value="2020" xsi:type="Literal"/>
               <month valueType="t:Integer" value="1" xsi:type="Literal"/>
               <day valueType="t:Integer" value="1" xsi:type="Literal"/>
               <hour valueType="t:Integer" value="0" xsi:type="Literal"/>
               <minute valueType="t:Integer" value="0" xsi:type="Literal"/>
               <second valueType="t:Integer" value="0" xsi:type="Literal"/>
               <millisecond valueType="t:Integer" value="0" xsi:type="Literal"/>
            </high>
         </default>
         <parameterTypeSpecifier localId="22" locator="34:32-34:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="21" locator="34:41-34:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <valueSets>
      <def localId="7" locator="22:1-22:97" name="ONC Administrative Sex" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1" accessLevel="Public"/>
      <def localId="8" locator="23:1-23:82" name="Race" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.836" accessLevel="Public"/>
      <def localId="9" locator="24:1-24:87" name="Ethnicity" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.837" accessLevel="Public"/>
      <def localId="10" locator="25:1-25:84" name="Payer" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" accessLevel="Public"/>
      <def localId="11" locator="26:1-26:103" name="Colonoscopy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1020" accessLevel="Public"/>
      <def localId="12" locator="27:1-27:122" name="Fecal Occult Blood Test (FOBT)" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1011" accessLevel="Public"/>
      <def localId="13" locator="28:1-28:114" name="Flexible Sigmoidoscopy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1010" accessLevel="Public"/>
      <def localId="14" locator="29:1-29:119" name="Malignant Neoplasm of Colon" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1001" accessLevel="Public"/>
      <def localId="15" locator="30:1-30:107" name="Total Colectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1019" accessLevel="Public"/>
      <def localId="16" locator="31:1-31:99" name="FIT DNA" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1039" accessLevel="Public"/>
      <def localId="17" locator="32:1-32:107" name="CT Colonography" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1038" accessLevel="Public"/>
   </valueSets>
   <statements>
      <def locator="37:1-37:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="37:1-37:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/StructureDefinition/Patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="26" locator="39:1-40:21" name="SDE Ethnicity" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="26">
               <a:s>define &quot;SDE Ethnicity&quot;:&#xd;
  </a:s>
               <a:s r="25">
                  <a:s r="24">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="25">
                     <a:s>&quot;SDE Ethnicity&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="25" locator="40:3-40:21" name="SDE Ethnicity" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="29" locator="42:1-43:17" name="SDE Payer" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="29">
               <a:s>define &quot;SDE Payer&quot;:&#xd;
  </a:s>
               <a:s r="28">
                  <a:s r="27">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="28">
                     <a:s>&quot;SDE Payer&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="28" locator="43:3-43:17" name="SDE Payer" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="32" locator="45:1-46:16" name="SDE Race" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="32">
               <a:s>define &quot;SDE Race&quot;:&#xd;
  </a:s>
               <a:s r="31">
                  <a:s r="30">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="31">
                     <a:s>&quot;SDE Race&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="31" locator="46:3-46:16" name="SDE Race" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="35" locator="48:1-49:15" name="SDE Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="35">
               <a:s>define &quot;SDE Sex&quot;:&#xd;
  </a:s>
               <a:s r="34">
                  <a:s r="33">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="34">
                     <a:s>&quot;SDE Sex&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="34" locator="49:3-49:15" name="SDE Sex" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="37" locator="51:1-52:5" name="Denominator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="37">
               <a:s r="36">define &quot;Denominator&quot;:&#xd;
	true</a:s>
            </a:s>
         </annotation>
         <expression localId="36" locator="52:2-52:5" valueType="t:Boolean" value="true" xsi:type="Literal"/>
      </def>
      <def localId="54" locator="54:1-57:129" name="Flexible Sigmoidoscopy Performed" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="54">
               <a:s>define &quot;Flexible Sigmoidoscopy Performed&quot;:&#xd;
	</a:s>
               <a:s r="53">
                  <a:s>
                     <a:s r="39">
                        <a:s r="38">
                           <a:s r="38">
                              <a:s>[Procedure: </a:s>
                              <a:s>
                                 <a:s>&quot;Flexible Sigmoidoscopy&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> FlexibleSigmoidoscopy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="52">
                     <a:s>where </a:s>
                     <a:s r="52">
                        <a:s r="43">
                           <a:s r="41">
                              <a:s r="40">
                                 <a:s>FlexibleSigmoidoscopy</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="41">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="42">
                              <a:s>'completed'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
			and </a:s>
                        <a:s r="51">
                           <a:s r="47">
                              <a:s r="44">
                                 <a:s>Global</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="47">
                                 <a:s>&quot;Normalize Interval&quot;(</a:s>
                                 <a:s r="46">
                                    <a:s r="45">
                                       <a:s>FlexibleSigmoidoscopy</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="46">
                                       <a:s>performed</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="51">
                              <a:s>ends </a:s>
                              <a:s r="50">
                                 <a:s>5 years</a:s>
                              </a:s>
                              <a:s> or less on or before</a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="49">
                              <a:s>end of </a:s>
                              <a:s r="48">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="53" locator="55:2-57:129" xsi:type="Query">
            <source localId="39" locator="55:2-55:60" alias="FlexibleSigmoidoscopy">
               <expression localId="38" locator="55:2-55:38" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/StructureDefinition/Procedure" codeProperty="code" xsi:type="Retrieve">
                  <codes locator="55:14-55:37" name="Flexible Sigmoidoscopy" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="52" locator="56:3-57:129" xsi:type="And">
               <operand localId="43" locator="56:9-56:50" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="41" locator="56:9-56:36" path="status" scope="FlexibleSigmoidoscopy" xsi:type="Property"/>
                  </operand>
                  <operand localId="42" locator="56:40-56:50" valueType="t:String" value="completed" xsi:type="Literal"/>
               </operand>
               <operand localId="51" locator="57:8-57:129" xsi:type="And">
                  <operand locator="57:74-57:88" xsi:type="In">
                     <operand locator="57:69-57:72" xsi:type="End">
                        <operand localId="47" locator="57:8-57:67" name="Normalize Interval" libraryName="Global" xsi:type="FunctionRef">
                           <operand localId="46" locator="57:36-57:66" path="performed" scope="FlexibleSigmoidoscopy" xsi:type="Property"/>
                        </operand>
                     </operand>
                     <operand locator="57:74-57:88" lowClosed="true" highClosed="true" xsi:type="Interval">
                        <low locator="57:103-57:129" xsi:type="Subtract">
                           <operand localId="49" locator="57:103-57:129" xsi:type="End">
                              <operand localId="48" locator="57:110-57:129" name="Measurement Period" xsi:type="ParameterRef"/>
                           </operand>
                           <operand localId="50" locator="57:74-57:80" value="5" unit="years" xsi:type="Quantity"/>
                        </low>
                        <high localId="49" locator="57:103-57:129" xsi:type="End">
                           <operand localId="48" locator="57:110-57:129" name="Measurement Period" xsi:type="ParameterRef"/>
                        </high>
                     </operand>
                  </operand>
                  <operand locator="57:74-57:88" xsi:type="Not">
                     <operand locator="57:74-57:88" xsi:type="IsNull">
                        <operand localId="49" locator="57:103-57:129" xsi:type="End">
                           <operand localId="48" locator="57:110-57:129" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="71" locator="59:1-62:120" name="CT Colonography Performed" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="71">
               <a:s>define &quot;CT Colonography Performed&quot;:&#xd;
	</a:s>
               <a:s r="70">
                  <a:s>
                     <a:s r="56">
                        <a:s r="55">
                           <a:s r="55">
                              <a:s>[Procedure: </a:s>
                              <a:s>
                                 <a:s>&quot;CT Colonography&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> Colonography</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="69">
                     <a:s>where </a:s>
                     <a:s r="69">
                        <a:s r="60">
                           <a:s r="58">
                              <a:s r="57">
                                 <a:s>Colonography</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="58">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="59">
                              <a:s>'completed'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
			and </a:s>
                        <a:s r="68">
                           <a:s r="64">
                              <a:s r="61">
                                 <a:s>Global</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="64">
                                 <a:s>&quot;Normalize Interval&quot;(</a:s>
                                 <a:s r="63">
                                    <a:s r="62">
                                       <a:s>Colonography</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="63">
                                       <a:s>performed</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="68">
                              <a:s>ends </a:s>
                              <a:s r="67">
                                 <a:s>5 years</a:s>
                              </a:s>
                              <a:s> or less on or before</a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="66">
                              <a:s>end of </a:s>
                              <a:s r="65">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="70" locator="60:2-62:120" xsi:type="Query">
            <source localId="56" locator="60:2-60:44" alias="Colonography">
               <expression localId="55" locator="60:2-60:31" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/StructureDefinition/Procedure" codeProperty="code" xsi:type="Retrieve">
                  <codes locator="60:14-60:30" name="CT Colonography" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="69" locator="61:3-62:120" xsi:type="And">
               <operand localId="60" locator="61:9-61:41" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="58" locator="61:9-61:27" path="status" scope="Colonography" xsi:type="Property"/>
                  </operand>
                  <operand localId="59" locator="61:31-61:41" valueType="t:String" value="completed" xsi:type="Literal"/>
               </operand>
               <operand localId="68" locator="62:8-62:120" xsi:type="And">
                  <operand locator="62:65-62:79" xsi:type="In">
                     <operand locator="62:60-62:63" xsi:type="End">
                        <operand localId="64" locator="62:8-62:58" name="Normalize Interval" libraryName="Global" xsi:type="FunctionRef">
                           <operand localId="63" locator="62:36-62:57" path="performed" scope="Colonography" xsi:type="Property"/>
                        </operand>
                     </operand>
                     <operand locator="62:65-62:79" lowClosed="true" highClosed="true" xsi:type="Interval">
                        <low locator="62:94-62:120" xsi:type="Subtract">
                           <operand localId="66" locator="62:94-62:120" xsi:type="End">
                              <operand localId="65" locator="62:101-62:120" name="Measurement Period" xsi:type="ParameterRef"/>
                           </operand>
                           <operand localId="67" locator="62:65-62:71" value="5" unit="years" xsi:type="Quantity"/>
                        </low>
                        <high localId="66" locator="62:94-62:120" xsi:type="End">
                           <operand localId="65" locator="62:101-62:120" name="Measurement Period" xsi:type="ParameterRef"/>
                        </high>
                     </operand>
                  </operand>
                  <operand locator="62:65-62:79" xsi:type="Not">
                     <operand locator="62:65-62:79" xsi:type="IsNull">
                        <operand localId="66" locator="62:94-62:120" xsi:type="End">
                           <operand localId="65" locator="62:101-62:120" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="87" locator="64:1-67:103" name="Total Colectomy Performed" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="87">
               <a:s>define &quot;Total Colectomy Performed&quot;:&#xd;
	</a:s>
               <a:s r="86">
                  <a:s>
                     <a:s r="73">
                        <a:s r="72">
                           <a:s r="72">
                              <a:s>[Procedure: </a:s>
                              <a:s>
                                 <a:s>&quot;Total Colectomy&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> Colectomy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="85">
                     <a:s>where </a:s>
                     <a:s r="85">
                        <a:s r="77">
                           <a:s r="75">
                              <a:s r="74">
                                 <a:s>Colectomy</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="75">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="76">
                              <a:s>'completed'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
			and </a:s>
                        <a:s r="84">
                           <a:s r="81">
                              <a:s r="78">
                                 <a:s>Global</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="81">
                                 <a:s>&quot;Normalize Interval&quot;(</a:s>
                                 <a:s r="80">
                                    <a:s r="79">
                                       <a:s>Colectomy</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="80">
                                       <a:s>performed</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="84"> starts on or before </a:s>
                           <a:s r="83">
                              <a:s>end of </a:s>
                              <a:s r="82">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="86" locator="65:2-67:103" xsi:type="Query">
            <source localId="73" locator="65:2-65:41" alias="Colectomy">
               <expression localId="72" locator="65:2-65:31" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/StructureDefinition/Procedure" codeProperty="code" xsi:type="Retrieve">
                  <codes locator="65:14-65:30" name="Total Colectomy" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="85" locator="66:3-67:103" xsi:type="And">
               <operand localId="77" locator="66:9-66:38" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="75" locator="66:9-66:24" path="status" scope="Colectomy" xsi:type="Property"/>
                  </operand>
                  <operand localId="76" locator="66:28-66:38" valueType="t:String" value="completed" xsi:type="Literal"/>
               </operand>
               <operand localId="84" locator="67:8-67:103" xsi:type="SameOrBefore">
                  <operand locator="67:57-67:62" xsi:type="Start">
                     <operand localId="81" locator="67:8-67:55" name="Normalize Interval" libraryName="Global" xsi:type="FunctionRef">
                        <operand localId="80" locator="67:36-67:54" path="performed" scope="Colectomy" xsi:type="Property"/>
                     </operand>
                  </operand>
                  <operand localId="83" locator="67:77-67:103" xsi:type="End">
                     <operand localId="82" locator="67:84-67:103" name="Measurement Period" xsi:type="ParameterRef"/>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="98" locator="69:1-71:107" name="Malignant Neoplasm Ever" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="98">
               <a:s>define &quot;Malignant Neoplasm Ever&quot;:&#xd;
	</a:s>
               <a:s r="97">
                  <a:s>
                     <a:s r="89">
                        <a:s r="88">
                           <a:s r="88">
                              <a:s>[Condition: </a:s>
                              <a:s>
                                 <a:s>&quot;Malignant Neoplasm of Colon&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> ColorectalCancer</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="96">
                     <a:s>where </a:s>
                     <a:s r="96">
                        <a:s r="93">
                           <a:s r="90">
                              <a:s>Global</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="93">
                              <a:s>&quot;Normalize Interval&quot;(</a:s>
                              <a:s r="92">
                                 <a:s r="91">
                                    <a:s>ColorectalCancer</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="92">
                                    <a:s>onset</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="96"> starts on or before </a:s>
                        <a:s r="95">
                           <a:s>end of </a:s>
                           <a:s r="94">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="97" locator="70:2-71:107" xsi:type="Query">
            <source localId="89" locator="70:2-70:60" alias="ColorectalCancer">
               <expression localId="88" locator="70:2-70:43" dataType="fhir:Condition" templateId="http://hl7.org/fhir/StructureDefinition/Condition" codeProperty="code" xsi:type="Retrieve">
                  <codes locator="70:14-70:42" name="Malignant Neoplasm of Colon" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="96" locator="71:3-71:107" xsi:type="SameOrBefore">
               <operand locator="71:61-71:66" xsi:type="Start">
                  <operand localId="93" locator="71:9-71:59" name="Normalize Interval" libraryName="Global" xsi:type="FunctionRef">
                     <operand localId="92" locator="71:37-71:58" path="onset" scope="ColorectalCancer" xsi:type="Property"/>
                  </operand>
               </operand>
               <operand localId="95" locator="71:81-71:107" xsi:type="End">
                  <operand localId="94" locator="71:88-71:107" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="121" locator="73:1-77:98" name="Fecal Occult Blood Test Performed" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="121">
               <a:s>define &quot;Fecal Occult Blood Test Performed&quot;:&#xd;
	</a:s>
               <a:s r="120">
                  <a:s>
                     <a:s r="100">
                        <a:s r="99">
                           <a:s r="99">
                              <a:s>[Observation: </a:s>
                              <a:s>
                                 <a:s>&quot;Fecal Occult Blood Test (FOBT)&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> FecalOccultResult</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="119">
                     <a:s>where </a:s>
                     <a:s r="119">
                        <a:s r="112">
                           <a:s r="108">
                              <a:s r="102">
                                 <a:s r="101">
                                    <a:s>FecalOccultResult</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="102">
                                    <a:s>status</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> in </a:s>
                              <a:s r="107">
                                 <a:s>{</a:s>
                                 <a:s r="103">
                                    <a:s>'final'</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="104">
                                    <a:s>'amended'</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="105">
                                    <a:s>'corrected'</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="106">
                                    <a:s>'preliminary'</a:s>
                                 </a:s>
                                 <a:s>}</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
			and </a:s>
                           <a:s r="111">
                              <a:s r="110">
                                 <a:s r="109">
                                    <a:s>FecalOccultResult</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="110">
                                    <a:s>value</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> is not null</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
			and </a:s>
                        <a:s r="118">
                           <a:s r="116">
                              <a:s r="113">
                                 <a:s>Global</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="116">
                                 <a:s>&quot;Normalize Interval&quot;(</a:s>
                                 <a:s r="115">
                                    <a:s r="114">
                                       <a:s>FecalOccultResult</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="115">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="118"> during day of </a:s>
                           <a:s r="117">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="120" locator="74:2-77:98" xsi:type="Query">
            <source localId="100" locator="74:2-74:66" alias="FecalOccultResult">
               <expression localId="99" locator="74:2-74:48" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/Observation" codeProperty="code" xsi:type="Retrieve">
                  <codes locator="74:16-74:47" name="Fecal Occult Blood Test (FOBT)" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="119" locator="75:3-77:98" xsi:type="And">
               <operand localId="112" locator="75:9-76:42" xsi:type="And">
                  <operand localId="108" locator="75:9-75:84" xsi:type="In">
                     <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="102" locator="75:9-75:32" path="status" scope="FecalOccultResult" xsi:type="Property"/>
                     </operand>
                     <operand localId="107" locator="75:37-75:84" xsi:type="List">
                        <element localId="103" locator="75:38-75:44" valueType="t:String" value="final" xsi:type="Literal"/>
                        <element localId="104" locator="75:47-75:55" valueType="t:String" value="amended" xsi:type="Literal"/>
                        <element localId="105" locator="75:58-75:68" valueType="t:String" value="corrected" xsi:type="Literal"/>
                        <element localId="106" locator="75:71-75:83" valueType="t:String" value="preliminary" xsi:type="Literal"/>
                     </operand>
                  </operand>
                  <operand localId="111" locator="76:8-76:42" xsi:type="Not">
                     <operand locator="76:8-76:42" xsi:type="IsNull">
                        <operand localId="110" locator="76:8-76:30" path="value" scope="FecalOccultResult" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="118" locator="77:8-77:98" precision="Day" xsi:type="IncludedIn">
                  <operand localId="116" locator="77:8-77:63" name="Normalize Interval" libraryName="Global" xsi:type="FunctionRef">
                     <operand localId="115" locator="77:36-77:62" path="effective" scope="FecalOccultResult" xsi:type="Property"/>
                  </operand>
                  <operand localId="117" locator="77:79-77:98" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="146" locator="79:1-83:123" name="Fecal Immunochemical Test DNA" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="146">
               <a:s>define &quot;Fecal Immunochemical Test DNA&quot;:&#xd;
	</a:s>
               <a:s r="145">
                  <a:s>
                     <a:s r="123">
                        <a:s r="122">
                           <a:s r="122">
                              <a:s>[Observation: </a:s>
                              <a:s>
                                 <a:s>&quot;FIT DNA&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> FitDNA</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="144">
                     <a:s>where </a:s>
                     <a:s r="144">
                        <a:s r="135">
                           <a:s r="131">
                              <a:s r="125">
                                 <a:s r="124">
                                    <a:s>FitDNA</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="125">
                                    <a:s>status</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> in </a:s>
                              <a:s r="130">
                                 <a:s>{</a:s>
                                 <a:s r="126">
                                    <a:s>'final'</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="127">
                                    <a:s>'amended'</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="128">
                                    <a:s>'corrected'</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="129">
                                    <a:s>'preliminary'</a:s>
                                 </a:s>
                                 <a:s>}</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
			and </a:s>
                           <a:s r="134">
                              <a:s r="133">
                                 <a:s r="132">
                                    <a:s>FitDNA</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="133">
                                    <a:s>value</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> is not null</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
			and </a:s>
                        <a:s r="143">
                           <a:s r="139">
                              <a:s r="136">
                                 <a:s>Global</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="139">
                                 <a:s>&quot;Normalize Interval&quot;(</a:s>
                                 <a:s r="138">
                                    <a:s r="137">
                                       <a:s>FitDNA</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="138">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="143">
                              <a:s>occurs </a:s>
                              <a:s r="142">
                                 <a:s>3 years</a:s>
                              </a:s>
                              <a:s> or less on or before day of</a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="141">
                              <a:s>end of </a:s>
                              <a:s r="140">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="145" locator="80:2-83:123" xsi:type="Query">
            <source localId="123" locator="80:2-80:32" alias="FitDNA">
               <expression localId="122" locator="80:2-80:25" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/Observation" codeProperty="code" xsi:type="Retrieve">
                  <codes locator="80:16-80:24" name="FIT DNA" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="144" locator="81:3-83:123" xsi:type="And">
               <operand localId="135" locator="81:9-82:31" xsi:type="And">
                  <operand localId="131" locator="81:9-81:73" xsi:type="In">
                     <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="125" locator="81:9-81:21" path="status" scope="FitDNA" xsi:type="Property"/>
                     </operand>
                     <operand localId="130" locator="81:26-81:73" xsi:type="List">
                        <element localId="126" locator="81:27-81:33" valueType="t:String" value="final" xsi:type="Literal"/>
                        <element localId="127" locator="81:36-81:44" valueType="t:String" value="amended" xsi:type="Literal"/>
                        <element localId="128" locator="81:47-81:57" valueType="t:String" value="corrected" xsi:type="Literal"/>
                        <element localId="129" locator="81:60-81:72" valueType="t:String" value="preliminary" xsi:type="Literal"/>
                     </operand>
                  </operand>
                  <operand localId="134" locator="82:8-82:31" xsi:type="Not">
                     <operand locator="82:8-82:31" xsi:type="IsNull">
                        <operand localId="133" locator="82:8-82:19" path="value" scope="FitDNA" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="143" locator="83:8-83:123" xsi:type="And">
                  <operand locator="83:61-83:75" precision="Day" xsi:type="In">
                     <operand locator="83:15-83:52" xsi:type="End">
                        <operand localId="139" locator="83:8-83:52" name="Normalize Interval" libraryName="Global" xsi:type="FunctionRef">
                           <operand localId="138" locator="83:36-83:51" path="effective" scope="FitDNA" xsi:type="Property"/>
                        </operand>
                     </operand>
                     <operand locator="83:61-83:75" lowClosed="true" highClosed="true" xsi:type="Interval">
                        <low locator="83:97-83:123" xsi:type="Subtract">
                           <operand localId="141" locator="83:97-83:123" xsi:type="End">
                              <operand localId="140" locator="83:104-83:123" name="Measurement Period" xsi:type="ParameterRef"/>
                           </operand>
                           <operand localId="142" locator="83:61-83:67" value="3" unit="years" xsi:type="Quantity"/>
                        </low>
                        <high localId="141" locator="83:97-83:123" xsi:type="End">
                           <operand localId="140" locator="83:104-83:123" name="Measurement Period" xsi:type="ParameterRef"/>
                        </high>
                     </operand>
                  </operand>
                  <operand locator="83:61-83:75" xsi:type="Not">
                     <operand locator="83:61-83:75" xsi:type="IsNull">
                        <operand localId="141" locator="83:97-83:123" xsi:type="End">
                           <operand localId="140" locator="83:104-83:123" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="163" locator="85:1-88:121" name="Colonoscopy Performed" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="163">
               <a:s>define &quot;Colonoscopy Performed&quot;:&#xd;
	</a:s>
               <a:s r="162">
                  <a:s>
                     <a:s r="148">
                        <a:s r="147">
                           <a:s r="147">
                              <a:s>[Procedure: </a:s>
                              <a:s>
                                 <a:s>&quot;Colonoscopy&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> Colonoscopy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="161">
                     <a:s>where </a:s>
                     <a:s r="161">
                        <a:s r="152">
                           <a:s r="150">
                              <a:s r="149">
                                 <a:s>Colonoscopy</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="150">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="151">
                              <a:s>'completed'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
		  and </a:s>
                        <a:s r="160">
                           <a:s r="156">
                              <a:s r="153">
                                 <a:s>Global</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="156">
                                 <a:s>&quot;Normalize Interval&quot;(</a:s>
                                 <a:s r="155">
                                    <a:s r="154">
                                       <a:s>Colonoscopy</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="155">
                                       <a:s>performed</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="160">
                              <a:s>ends </a:s>
                              <a:s r="159">
                                 <a:s>10 years</a:s>
                              </a:s>
                              <a:s> or less on or before</a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="158">
                              <a:s>end of </a:s>
                              <a:s r="157">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="162" locator="86:2-88:121" xsi:type="Query">
            <source localId="148" locator="86:2-86:39" alias="Colonoscopy">
               <expression localId="147" locator="86:2-86:27" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/StructureDefinition/Procedure" codeProperty="code" xsi:type="Retrieve">
                  <codes locator="86:14-86:26" name="Colonoscopy" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="161" locator="87:3-88:121" xsi:type="And">
               <operand localId="152" locator="87:9-87:40" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="150" locator="87:9-87:26" path="status" scope="Colonoscopy" xsi:type="Property"/>
                  </operand>
                  <operand localId="151" locator="87:30-87:40" valueType="t:String" value="completed" xsi:type="Literal"/>
               </operand>
               <operand localId="160" locator="88:9-88:121" xsi:type="And">
                  <operand locator="88:65-88:80" xsi:type="In">
                     <operand locator="88:60-88:63" xsi:type="End">
                        <operand localId="156" locator="88:9-88:58" name="Normalize Interval" libraryName="Global" xsi:type="FunctionRef">
                           <operand localId="155" locator="88:37-88:57" path="performed" scope="Colonoscopy" xsi:type="Property"/>
                        </operand>
                     </operand>
                     <operand locator="88:65-88:80" lowClosed="true" highClosed="true" xsi:type="Interval">
                        <low locator="88:95-88:121" xsi:type="Subtract">
                           <operand localId="158" locator="88:95-88:121" xsi:type="End">
                              <operand localId="157" locator="88:102-88:121" name="Measurement Period" xsi:type="ParameterRef"/>
                           </operand>
                           <operand localId="159" locator="88:65-88:72" value="10" unit="years" xsi:type="Quantity"/>
                        </low>
                        <high localId="158" locator="88:95-88:121" xsi:type="End">
                           <operand localId="157" locator="88:102-88:121" name="Measurement Period" xsi:type="ParameterRef"/>
                        </high>
                     </operand>
                  </operand>
                  <operand locator="88:65-88:80" xsi:type="Not">
                     <operand locator="88:65-88:80" xsi:type="IsNull">
                        <operand localId="158" locator="88:95-88:121" xsi:type="End">
                           <operand localId="157" locator="88:102-88:121" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="178" locator="90:1-95:39" name="Numerator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="178">
               <a:s>define &quot;Numerator&quot;:&#xd;
	</a:s>
               <a:s r="177">
                  <a:s r="174">
                     <a:s r="171">
                        <a:s r="168">
                           <a:s r="165">
                              <a:s>exists </a:s>
                              <a:s r="164">
                                 <a:s>&quot;Colonoscopy Performed&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
		or </a:s>
                           <a:s r="167">
                              <a:s>exists </a:s>
                              <a:s r="166">
                                 <a:s>&quot;Fecal Occult Blood Test Performed&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
		or </a:s>
                        <a:s r="170">
                           <a:s>exists </a:s>
                           <a:s r="169">
                              <a:s>&quot;Flexible Sigmoidoscopy Performed&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		or </a:s>
                     <a:s r="173">
                        <a:s>exists </a:s>
                        <a:s r="172">
                           <a:s>&quot;Fecal Immunochemical Test DNA&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		or </a:s>
                  <a:s r="176">
                     <a:s>exists </a:s>
                     <a:s r="175">
                        <a:s>&quot;CT Colonography Performed&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="177" locator="91:2-95:39" xsi:type="Or">
            <operand localId="174" locator="91:2-94:43" xsi:type="Or">
               <operand localId="171" locator="91:2-93:46" xsi:type="Or">
                  <operand localId="168" locator="91:2-92:47" xsi:type="Or">
                     <operand localId="165" locator="91:2-91:31" xsi:type="Exists">
                        <operand localId="164" locator="91:9-91:31" name="Colonoscopy Performed" xsi:type="ExpressionRef"/>
                     </operand>
                     <operand localId="167" locator="92:6-92:47" xsi:type="Exists">
                        <operand localId="166" locator="92:13-92:47" name="Fecal Occult Blood Test Performed" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
                  <operand localId="170" locator="93:6-93:46" xsi:type="Exists">
                     <operand localId="169" locator="93:13-93:46" name="Flexible Sigmoidoscopy Performed" xsi:type="ExpressionRef"/>
                  </operand>
               </operand>
               <operand localId="173" locator="94:6-94:43" xsi:type="Exists">
                  <operand localId="172" locator="94:13-94:43" name="Fecal Immunochemical Test DNA" xsi:type="ExpressionRef"/>
               </operand>
            </operand>
            <operand localId="176" locator="95:6-95:39" xsi:type="Exists">
               <operand localId="175" locator="95:13-95:39" name="CT Colonography Performed" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="187" locator="97:1-100:39" name="Denominator Exclusion" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="187">
               <a:s>define &quot;Denominator Exclusion&quot;:&#xd;
	</a:s>
               <a:s r="186">
                  <a:s r="183">
                     <a:s r="180">
                        <a:s r="179">
                           <a:s>Hospice</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="180">
                           <a:s>&quot;Has Hospice&quot;</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		or </a:s>
                     <a:s r="182">
                        <a:s>exists </a:s>
                        <a:s r="181">
                           <a:s>&quot;Malignant Neoplasm Ever&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		or </a:s>
                  <a:s r="185">
                     <a:s>exists </a:s>
                     <a:s r="184">
                        <a:s>&quot;Total Colectomy Performed&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="186" locator="98:2-100:39" xsi:type="Or">
            <operand localId="183" locator="98:2-99:37" xsi:type="Or">
               <operand localId="180" locator="98:2-98:22" name="Has Hospice" libraryName="Hospice" xsi:type="ExpressionRef"/>
               <operand localId="182" locator="99:6-99:37" xsi:type="Exists">
                  <operand localId="181" locator="99:13-99:37" name="Malignant Neoplasm Ever" xsi:type="ExpressionRef"/>
               </operand>
            </operand>
            <operand localId="185" locator="100:6-100:39" xsi:type="Exists">
               <operand localId="184" locator="100:13-100:39" name="Total Colectomy Performed" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="204" locator="102:1-104:63" name="Initial Population" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="204">
               <a:s>define &quot;Initial Population&quot;:&#xd;
	</a:s>
               <a:s r="203">
                  <a:s r="199">
                     <a:s r="195">
                        <a:s r="188">
                           <a:s>Global</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="195">
                           <a:s>&quot;CalendarAgeInYearsAt&quot;(</a:s>
                           <a:s r="192">
                              <a:s r="189">
                                 <a:s>FHIRHelpers</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="192">
                                 <a:s>ToDate(</a:s>
                                 <a:s r="191">
                                    <a:s r="190">
                                       <a:s>Patient</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="191">
                                       <a:s>birthDate</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="194">
                              <a:s>start of </a:s>
                              <a:s r="193">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s> in </a:s>
                     <a:s r="198">
                        <a:s r="196">Interval[50, 75]</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
			and </a:s>
                  <a:s r="202">
                     <a:s>exists </a:s>
                     <a:s r="201">
                        <a:s r="200">
                           <a:s>AdultOutpatientEncounters</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="201">
                           <a:s>&quot;Qualifying Encounters&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="203" locator="103:2-104:63" xsi:type="And">
            <operand localId="199" locator="103:2-103:120" xsi:type="In">
               <operand localId="195" locator="103:2-103:100" name="CalendarAgeInYearsAt" libraryName="Global" xsi:type="FunctionRef">
                  <operand xsi:type="ToDateTime">
                     <operand localId="192" locator="103:32-103:68" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="191" locator="103:51-103:67" path="birthDate" xsi:type="Property">
                           <source localId="190" locator="103:51-103:57" name="Patient" xsi:type="ExpressionRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="194" locator="103:71-103:99" xsi:type="Start">
                     <operand localId="193" locator="103:80-103:99" name="Measurement Period" xsi:type="ParameterRef"/>
                  </operand>
               </operand>
               <operand localId="198" locator="103:105-103:120" lowClosed="true" highClosed="true" xsi:type="Interval">
                  <low localId="196" locator="103:114-103:115" valueType="t:Integer" value="50" xsi:type="Literal"/>
                  <high localId="197" locator="103:118-103:119" valueType="t:Integer" value="75" xsi:type="Literal"/>
               </operand>
            </operand>
            <operand localId="202" locator="104:8-104:63" xsi:type="Exists">
               <operand localId="201" locator="104:15-104:63" name="Qualifying Encounters" libraryName="AdultOutpatientEncounters" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorVersion" : "1.3",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      } ],
      "identifier" : {
         "id" : "EXM130",
         "system" : "http://fhir.org/guides/dbcg/connectathon",
         "version" : "7.3.000"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "14:1-14:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1"
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "2",
            "locator" : "16:1-16:54",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/dbcg/connectathon/FHIRHelpers",
            "version" : "4.0.1"
         }, {
            "localId" : "3",
            "locator" : "17:1-17:48",
            "localIdentifier" : "Hospice",
            "path" : "http://fhir.org/guides/dbcg/connectathon/Hospice",
            "version" : "2.0.000"
         }, {
            "localId" : "4",
            "locator" : "18:1-18:84",
            "localIdentifier" : "AdultOutpatientEncounters",
            "path" : "http://fhir.org/guides/dbcg/connectathon/AdultOutpatientEncounters",
            "version" : "2.0.000"
         }, {
            "localId" : "5",
            "locator" : "19:1-19:64",
            "localIdentifier" : "Global",
            "path" : "http://fhir.org/guides/dbcg/connectathon/MATGlobalCommonFunctions",
            "version" : "5.0.000"
         }, {
            "localId" : "6",
            "locator" : "20:1-20:59",
            "localIdentifier" : "SDE",
            "path" : "http://fhir.org/guides/dbcg/connectathon/SupplementalDataElements",
            "version" : "2.0.0"
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "23",
            "locator" : "34:1-35:66",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "default" : {
               "localId" : "20",
               "locator" : "35:11-35:66",
               "lowClosed" : true,
               "highClosed" : false,
               "type" : "Interval",
               "low" : {
                  "localId" : "18",
                  "locator" : "35:20-35:41",
                  "type" : "DateTime",
                  "year" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2019",
                     "type" : "Literal"
                  },
                  "month" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "day" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "hour" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "minute" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "second" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "millisecond" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               },
               "high" : {
                  "localId" : "19",
                  "locator" : "35:44-35:65",
                  "type" : "DateTime",
                  "year" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2020",
                     "type" : "Literal"
                  },
                  "month" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "day" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "hour" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "minute" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "second" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "millisecond" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               }
            },
            "parameterTypeSpecifier" : {
               "localId" : "22",
               "locator" : "34:32-34:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "21",
                  "locator" : "34:41-34:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "7",
            "locator" : "22:1-22:97",
            "name" : "ONC Administrative Sex",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1",
            "accessLevel" : "Public"
         }, {
            "localId" : "8",
            "locator" : "23:1-23:82",
            "name" : "Race",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.836",
            "accessLevel" : "Public"
         }, {
            "localId" : "9",
            "locator" : "24:1-24:87",
            "name" : "Ethnicity",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.837",
            "accessLevel" : "Public"
         }, {
            "localId" : "10",
            "locator" : "25:1-25:84",
            "name" : "Payer",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591",
            "accessLevel" : "Public"
         }, {
            "localId" : "11",
            "locator" : "26:1-26:103",
            "name" : "Colonoscopy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1020",
            "accessLevel" : "Public"
         }, {
            "localId" : "12",
            "locator" : "27:1-27:122",
            "name" : "Fecal Occult Blood Test (FOBT)",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1011",
            "accessLevel" : "Public"
         }, {
            "localId" : "13",
            "locator" : "28:1-28:114",
            "name" : "Flexible Sigmoidoscopy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1010",
            "accessLevel" : "Public"
         }, {
            "localId" : "14",
            "locator" : "29:1-29:119",
            "name" : "Malignant Neoplasm of Colon",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1001",
            "accessLevel" : "Public"
         }, {
            "localId" : "15",
            "locator" : "30:1-30:107",
            "name" : "Total Colectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1019",
            "accessLevel" : "Public"
         }, {
            "localId" : "16",
            "locator" : "31:1-31:99",
            "name" : "FIT DNA",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1039",
            "accessLevel" : "Public"
         }, {
            "localId" : "17",
            "locator" : "32:1-32:107",
            "name" : "CT Colonography",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1038",
            "accessLevel" : "Public"
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "37:1-37:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "37:1-37:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/StructureDefinition/Patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "26",
            "locator" : "39:1-40:21",
            "name" : "SDE Ethnicity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "26",
                  "s" : [ {
                     "value" : [ "define ","\"SDE Ethnicity\"",":\r\n  " ]
                  }, {
                     "r" : "25",
                     "s" : [ {
                        "r" : "24",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "25",
                        "s" : [ {
                           "value" : [ "\"SDE Ethnicity\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "25",
               "locator" : "40:3-40:21",
               "name" : "SDE Ethnicity",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "29",
            "locator" : "42:1-43:17",
            "name" : "SDE Payer",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "29",
                  "s" : [ {
                     "value" : [ "define ","\"SDE Payer\"",":\r\n  " ]
                  }, {
                     "r" : "28",
                     "s" : [ {
                        "r" : "27",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "28",
                        "s" : [ {
                           "value" : [ "\"SDE Payer\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "28",
               "locator" : "43:3-43:17",
               "name" : "SDE Payer",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "32",
            "locator" : "45:1-46:16",
            "name" : "SDE Race",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "32",
                  "s" : [ {
                     "value" : [ "define ","\"SDE Race\"",":\r\n  " ]
                  }, {
                     "r" : "31",
                     "s" : [ {
                        "r" : "30",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "31",
                        "s" : [ {
                           "value" : [ "\"SDE Race\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "31",
               "locator" : "46:3-46:16",
               "name" : "SDE Race",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "35",
            "locator" : "48:1-49:15",
            "name" : "SDE Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "35",
                  "s" : [ {
                     "value" : [ "define ","\"SDE Sex\"",":\r\n  " ]
                  }, {
                     "r" : "34",
                     "s" : [ {
                        "r" : "33",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "34",
                        "s" : [ {
                           "value" : [ "\"SDE Sex\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "34",
               "locator" : "49:3-49:15",
               "name" : "SDE Sex",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "37",
            "locator" : "51:1-52:5",
            "name" : "Denominator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "37",
                  "s" : [ {
                     "r" : "36",
                     "value" : [ "define ","\"Denominator\"",":\r\n\t","true" ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "36",
               "locator" : "52:2-52:5",
               "valueType" : "{urn:hl7-org:elm-types:r1}Boolean",
               "value" : "true",
               "type" : "Literal"
            }
         }, {
            "localId" : "54",
            "locator" : "54:1-57:129",
            "name" : "Flexible Sigmoidoscopy Performed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "54",
                  "s" : [ {
                     "value" : [ "define ","\"Flexible Sigmoidoscopy Performed\"",":\r\n\t" ]
                  }, {
                     "r" : "53",
                     "s" : [ {
                        "s" : [ {
                           "r" : "39",
                           "s" : [ {
                              "r" : "38",
                              "s" : [ {
                                 "r" : "38",
                                 "s" : [ {
                                    "value" : [ "[","Procedure",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"Flexible Sigmoidoscopy\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","FlexibleSigmoidoscopy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "52",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "52",
                           "s" : [ {
                              "r" : "43",
                              "s" : [ {
                                 "r" : "41",
                                 "s" : [ {
                                    "r" : "40",
                                    "s" : [ {
                                       "value" : [ "FlexibleSigmoidoscopy" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "41",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "42",
                                 "s" : [ {
                                    "value" : [ "'completed'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\t\t\tand " ]
                           }, {
                              "r" : "51",
                              "s" : [ {
                                 "r" : "47",
                                 "s" : [ {
                                    "r" : "44",
                                    "s" : [ {
                                       "value" : [ "Global" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "47",
                                    "s" : [ {
                                       "value" : [ "\"Normalize Interval\"","(" ]
                                    }, {
                                       "r" : "46",
                                       "s" : [ {
                                          "r" : "45",
                                          "s" : [ {
                                             "value" : [ "FlexibleSigmoidoscopy" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "46",
                                          "s" : [ {
                                             "value" : [ "performed" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "51",
                                 "s" : [ {
                                    "value" : [ "ends " ]
                                 }, {
                                    "r" : "50",
                                    "s" : [ {
                                       "value" : [ "5 ","years" ]
                                    } ]
                                 }, {
                                    "value" : [ " or less on or before" ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "49",
                                 "s" : [ {
                                    "value" : [ "end of " ]
                                 }, {
                                    "r" : "48",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "53",
               "locator" : "55:2-57:129",
               "type" : "Query",
               "source" : [ {
                  "localId" : "39",
                  "locator" : "55:2-55:60",
                  "alias" : "FlexibleSigmoidoscopy",
                  "expression" : {
                     "localId" : "38",
                     "locator" : "55:2-55:38",
                     "dataType" : "{http://hl7.org/fhir}Procedure",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Procedure",
                     "codeProperty" : "code",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "55:14-55:37",
                        "name" : "Flexible Sigmoidoscopy",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "52",
                  "locator" : "56:3-57:129",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "43",
                     "locator" : "56:9-56:50",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "41",
                           "locator" : "56:9-56:36",
                           "path" : "status",
                           "scope" : "FlexibleSigmoidoscopy",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "42",
                        "locator" : "56:40-56:50",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "completed",
                        "type" : "Literal"
                     } ]
                  }, {
                     "localId" : "51",
                     "locator" : "57:8-57:129",
                     "type" : "And",
                     "operand" : [ {
                        "locator" : "57:74-57:88",
                        "type" : "In",
                        "operand" : [ {
                           "locator" : "57:69-57:72",
                           "type" : "End",
                           "operand" : {
                              "localId" : "47",
                              "locator" : "57:8-57:67",
                              "name" : "Normalize Interval",
                              "libraryName" : "Global",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "46",
                                 "locator" : "57:36-57:66",
                                 "path" : "performed",
                                 "scope" : "FlexibleSigmoidoscopy",
                                 "type" : "Property"
                              } ]
                           }
                        }, {
                           "locator" : "57:74-57:88",
                           "lowClosed" : true,
                           "highClosed" : true,
                           "type" : "Interval",
                           "low" : {
                              "locator" : "57:103-57:129",
                              "type" : "Subtract",
                              "operand" : [ {
                                 "localId" : "49",
                                 "locator" : "57:103-57:129",
                                 "type" : "End",
                                 "operand" : {
                                    "localId" : "48",
                                    "locator" : "57:110-57:129",
                                    "name" : "Measurement Period",
                                    "type" : "ParameterRef"
                                 }
                              }, {
                                 "localId" : "50",
                                 "locator" : "57:74-57:80",
                                 "value" : 5,
                                 "unit" : "years",
                                 "type" : "Quantity"
                              } ]
                           },
                           "high" : {
                              "localId" : "49",
                              "locator" : "57:103-57:129",
                              "type" : "End",
                              "operand" : {
                                 "localId" : "48",
                                 "locator" : "57:110-57:129",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "locator" : "57:74-57:88",
                        "type" : "Not",
                        "operand" : {
                           "locator" : "57:74-57:88",
                           "type" : "IsNull",
                           "operand" : {
                              "localId" : "49",
                              "locator" : "57:103-57:129",
                              "type" : "End",
                              "operand" : {
                                 "localId" : "48",
                                 "locator" : "57:110-57:129",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        }
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "71",
            "locator" : "59:1-62:120",
            "name" : "CT Colonography Performed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "71",
                  "s" : [ {
                     "value" : [ "define ","\"CT Colonography Performed\"",":\r\n\t" ]
                  }, {
                     "r" : "70",
                     "s" : [ {
                        "s" : [ {
                           "r" : "56",
                           "s" : [ {
                              "r" : "55",
                              "s" : [ {
                                 "r" : "55",
                                 "s" : [ {
                                    "value" : [ "[","Procedure",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"CT Colonography\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","Colonography" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "69",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "69",
                           "s" : [ {
                              "r" : "60",
                              "s" : [ {
                                 "r" : "58",
                                 "s" : [ {
                                    "r" : "57",
                                    "s" : [ {
                                       "value" : [ "Colonography" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "58",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "59",
                                 "s" : [ {
                                    "value" : [ "'completed'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\t\t\tand " ]
                           }, {
                              "r" : "68",
                              "s" : [ {
                                 "r" : "64",
                                 "s" : [ {
                                    "r" : "61",
                                    "s" : [ {
                                       "value" : [ "Global" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "64",
                                    "s" : [ {
                                       "value" : [ "\"Normalize Interval\"","(" ]
                                    }, {
                                       "r" : "63",
                                       "s" : [ {
                                          "r" : "62",
                                          "s" : [ {
                                             "value" : [ "Colonography" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "63",
                                          "s" : [ {
                                             "value" : [ "performed" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "68",
                                 "s" : [ {
                                    "value" : [ "ends " ]
                                 }, {
                                    "r" : "67",
                                    "s" : [ {
                                       "value" : [ "5 ","years" ]
                                    } ]
                                 }, {
                                    "value" : [ " or less on or before" ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "66",
                                 "s" : [ {
                                    "value" : [ "end of " ]
                                 }, {
                                    "r" : "65",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "70",
               "locator" : "60:2-62:120",
               "type" : "Query",
               "source" : [ {
                  "localId" : "56",
                  "locator" : "60:2-60:44",
                  "alias" : "Colonography",
                  "expression" : {
                     "localId" : "55",
                     "locator" : "60:2-60:31",
                     "dataType" : "{http://hl7.org/fhir}Procedure",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Procedure",
                     "codeProperty" : "code",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "60:14-60:30",
                        "name" : "CT Colonography",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "69",
                  "locator" : "61:3-62:120",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "60",
                     "locator" : "61:9-61:41",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "58",
                           "locator" : "61:9-61:27",
                           "path" : "status",
                           "scope" : "Colonography",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "59",
                        "locator" : "61:31-61:41",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "completed",
                        "type" : "Literal"
                     } ]
                  }, {
                     "localId" : "68",
                     "locator" : "62:8-62:120",
                     "type" : "And",
                     "operand" : [ {
                        "locator" : "62:65-62:79",
                        "type" : "In",
                        "operand" : [ {
                           "locator" : "62:60-62:63",
                           "type" : "End",
                           "operand" : {
                              "localId" : "64",
                              "locator" : "62:8-62:58",
                              "name" : "Normalize Interval",
                              "libraryName" : "Global",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "63",
                                 "locator" : "62:36-62:57",
                                 "path" : "performed",
                                 "scope" : "Colonography",
                                 "type" : "Property"
                              } ]
                           }
                        }, {
                           "locator" : "62:65-62:79",
                           "lowClosed" : true,
                           "highClosed" : true,
                           "type" : "Interval",
                           "low" : {
                              "locator" : "62:94-62:120",
                              "type" : "Subtract",
                              "operand" : [ {
                                 "localId" : "66",
                                 "locator" : "62:94-62:120",
                                 "type" : "End",
                                 "operand" : {
                                    "localId" : "65",
                                    "locator" : "62:101-62:120",
                                    "name" : "Measurement Period",
                                    "type" : "ParameterRef"
                                 }
                              }, {
                                 "localId" : "67",
                                 "locator" : "62:65-62:71",
                                 "value" : 5,
                                 "unit" : "years",
                                 "type" : "Quantity"
                              } ]
                           },
                           "high" : {
                              "localId" : "66",
                              "locator" : "62:94-62:120",
                              "type" : "End",
                              "operand" : {
                                 "localId" : "65",
                                 "locator" : "62:101-62:120",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "locator" : "62:65-62:79",
                        "type" : "Not",
                        "operand" : {
                           "locator" : "62:65-62:79",
                           "type" : "IsNull",
                           "operand" : {
                              "localId" : "66",
                              "locator" : "62:94-62:120",
                              "type" : "End",
                              "operand" : {
                                 "localId" : "65",
                                 "locator" : "62:101-62:120",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        }
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "87",
            "locator" : "64:1-67:103",
            "name" : "Total Colectomy Performed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "87",
                  "s" : [ {
                     "value" : [ "define ","\"Total Colectomy Performed\"",":\r\n\t" ]
                  }, {
                     "r" : "86",
                     "s" : [ {
                        "s" : [ {
                           "r" : "73",
                           "s" : [ {
                              "r" : "72",
                              "s" : [ {
                                 "r" : "72",
                                 "s" : [ {
                                    "value" : [ "[","Procedure",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"Total Colectomy\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","Colectomy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "85",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "85",
                           "s" : [ {
                              "r" : "77",
                              "s" : [ {
                                 "r" : "75",
                                 "s" : [ {
                                    "r" : "74",
                                    "s" : [ {
                                       "value" : [ "Colectomy" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "75",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "76",
                                 "s" : [ {
                                    "value" : [ "'completed'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\t\t\tand " ]
                           }, {
                              "r" : "84",
                              "s" : [ {
                                 "r" : "81",
                                 "s" : [ {
                                    "r" : "78",
                                    "s" : [ {
                                       "value" : [ "Global" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "81",
                                    "s" : [ {
                                       "value" : [ "\"Normalize Interval\"","(" ]
                                    }, {
                                       "r" : "80",
                                       "s" : [ {
                                          "r" : "79",
                                          "s" : [ {
                                             "value" : [ "Colectomy" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "80",
                                          "s" : [ {
                                             "value" : [ "performed" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "84",
                                 "value" : [ " ","starts on or before"," " ]
                              }, {
                                 "r" : "83",
                                 "s" : [ {
                                    "value" : [ "end of " ]
                                 }, {
                                    "r" : "82",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "86",
               "locator" : "65:2-67:103",
               "type" : "Query",
               "source" : [ {
                  "localId" : "73",
                  "locator" : "65:2-65:41",
                  "alias" : "Colectomy",
                  "expression" : {
                     "localId" : "72",
                     "locator" : "65:2-65:31",
                     "dataType" : "{http://hl7.org/fhir}Procedure",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Procedure",
                     "codeProperty" : "code",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "65:14-65:30",
                        "name" : "Total Colectomy",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "85",
                  "locator" : "66:3-67:103",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "77",
                     "locator" : "66:9-66:38",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "75",
                           "locator" : "66:9-66:24",
                           "path" : "status",
                           "scope" : "Colectomy",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "76",
                        "locator" : "66:28-66:38",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "completed",
                        "type" : "Literal"
                     } ]
                  }, {
                     "localId" : "84",
                     "locator" : "67:8-67:103",
                     "type" : "SameOrBefore",
                     "operand" : [ {
                        "locator" : "67:57-67:62",
                        "type" : "Start",
                        "operand" : {
                           "localId" : "81",
                           "locator" : "67:8-67:55",
                           "name" : "Normalize Interval",
                           "libraryName" : "Global",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "80",
                              "locator" : "67:36-67:54",
                              "path" : "performed",
                              "scope" : "Colectomy",
                              "type" : "Property"
                           } ]
                        }
                     }, {
                        "localId" : "83",
                        "locator" : "67:77-67:103",
                        "type" : "End",
                        "operand" : {
                           "localId" : "82",
                           "locator" : "67:84-67:103",
                           "name" : "Measurement Period",
                           "type" : "ParameterRef"
                        }
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "98",
            "locator" : "69:1-71:107",
            "name" : "Malignant Neoplasm Ever",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "98",
                  "s" : [ {
                     "value" : [ "define ","\"Malignant Neoplasm Ever\"",":\r\n\t" ]
                  }, {
                     "r" : "97",
                     "s" : [ {
                        "s" : [ {
                           "r" : "89",
                           "s" : [ {
                              "r" : "88",
                              "s" : [ {
                                 "r" : "88",
                                 "s" : [ {
                                    "value" : [ "[","Condition",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"Malignant Neoplasm of Colon\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","ColorectalCancer" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "96",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "96",
                           "s" : [ {
                              "r" : "93",
                              "s" : [ {
                                 "r" : "90",
                                 "s" : [ {
                                    "value" : [ "Global" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "93",
                                 "s" : [ {
                                    "value" : [ "\"Normalize Interval\"","(" ]
                                 }, {
                                    "r" : "92",
                                    "s" : [ {
                                       "r" : "91",
                                       "s" : [ {
                                          "value" : [ "ColorectalCancer" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "92",
                                       "s" : [ {
                                          "value" : [ "onset" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "96",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "95",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "94",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "97",
               "locator" : "70:2-71:107",
               "type" : "Query",
               "source" : [ {
                  "localId" : "89",
                  "locator" : "70:2-70:60",
                  "alias" : "ColorectalCancer",
                  "expression" : {
                     "localId" : "88",
                     "locator" : "70:2-70:43",
                     "dataType" : "{http://hl7.org/fhir}Condition",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Condition",
                     "codeProperty" : "code",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "70:14-70:42",
                        "name" : "Malignant Neoplasm of Colon",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "96",
                  "locator" : "71:3-71:107",
                  "type" : "SameOrBefore",
                  "operand" : [ {
                     "locator" : "71:61-71:66",
                     "type" : "Start",
                     "operand" : {
                        "localId" : "93",
                        "locator" : "71:9-71:59",
                        "name" : "Normalize Interval",
                        "libraryName" : "Global",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "92",
                           "locator" : "71:37-71:58",
                           "path" : "onset",
                           "scope" : "ColorectalCancer",
                           "type" : "Property"
                        } ]
                     }
                  }, {
                     "localId" : "95",
                     "locator" : "71:81-71:107",
                     "type" : "End",
                     "operand" : {
                        "localId" : "94",
                        "locator" : "71:88-71:107",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "121",
            "locator" : "73:1-77:98",
            "name" : "Fecal Occult Blood Test Performed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "121",
                  "s" : [ {
                     "value" : [ "define ","\"Fecal Occult Blood Test Performed\"",":\r\n\t" ]
                  }, {
                     "r" : "120",
                     "s" : [ {
                        "s" : [ {
                           "r" : "100",
                           "s" : [ {
                              "r" : "99",
                              "s" : [ {
                                 "r" : "99",
                                 "s" : [ {
                                    "value" : [ "[","Observation",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"Fecal Occult Blood Test (FOBT)\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","FecalOccultResult" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "119",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "119",
                           "s" : [ {
                              "r" : "112",
                              "s" : [ {
                                 "r" : "108",
                                 "s" : [ {
                                    "r" : "102",
                                    "s" : [ {
                                       "r" : "101",
                                       "s" : [ {
                                          "value" : [ "FecalOccultResult" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "102",
                                       "s" : [ {
                                          "value" : [ "status" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " in " ]
                                 }, {
                                    "r" : "107",
                                    "s" : [ {
                                       "value" : [ "{" ]
                                    }, {
                                       "r" : "103",
                                       "s" : [ {
                                          "value" : [ "'final'" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "104",
                                       "s" : [ {
                                          "value" : [ "'amended'" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "105",
                                       "s" : [ {
                                          "value" : [ "'corrected'" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "106",
                                       "s" : [ {
                                          "value" : [ "'preliminary'" ]
                                       } ]
                                    }, {
                                       "value" : [ "}" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n\t\t\tand " ]
                              }, {
                                 "r" : "111",
                                 "s" : [ {
                                    "r" : "110",
                                    "s" : [ {
                                       "r" : "109",
                                       "s" : [ {
                                          "value" : [ "FecalOccultResult" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "110",
                                       "s" : [ {
                                          "value" : [ "value" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " is not null" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\t\t\tand " ]
                           }, {
                              "r" : "118",
                              "s" : [ {
                                 "r" : "116",
                                 "s" : [ {
                                    "r" : "113",
                                    "s" : [ {
                                       "value" : [ "Global" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "116",
                                    "s" : [ {
                                       "value" : [ "\"Normalize Interval\"","(" ]
                                    }, {
                                       "r" : "115",
                                       "s" : [ {
                                          "r" : "114",
                                          "s" : [ {
                                             "value" : [ "FecalOccultResult" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "115",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "118",
                                 "value" : [ " ","during day of"," " ]
                              }, {
                                 "r" : "117",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "120",
               "locator" : "74:2-77:98",
               "type" : "Query",
               "source" : [ {
                  "localId" : "100",
                  "locator" : "74:2-74:66",
                  "alias" : "FecalOccultResult",
                  "expression" : {
                     "localId" : "99",
                     "locator" : "74:2-74:48",
                     "dataType" : "{http://hl7.org/fhir}Observation",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Observation",
                     "codeProperty" : "code",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "74:16-74:47",
                        "name" : "Fecal Occult Blood Test (FOBT)",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "119",
                  "locator" : "75:3-77:98",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "112",
                     "locator" : "75:9-76:42",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "108",
                        "locator" : "75:9-75:84",
                        "type" : "In",
                        "operand" : [ {
                           "name" : "ToString",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "102",
                              "locator" : "75:9-75:32",
                              "path" : "status",
                              "scope" : "FecalOccultResult",
                              "type" : "Property"
                           } ]
                        }, {
                           "localId" : "107",
                           "locator" : "75:37-75:84",
                           "type" : "List",
                           "element" : [ {
                              "localId" : "103",
                              "locator" : "75:38-75:44",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "final",
                              "type" : "Literal"
                           }, {
                              "localId" : "104",
                              "locator" : "75:47-75:55",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "amended",
                              "type" : "Literal"
                           }, {
                              "localId" : "105",
                              "locator" : "75:58-75:68",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "corrected",
                              "type" : "Literal"
                           }, {
                              "localId" : "106",
                              "locator" : "75:71-75:83",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "preliminary",
                              "type" : "Literal"
                           } ]
                        } ]
                     }, {
                        "localId" : "111",
                        "locator" : "76:8-76:42",
                        "type" : "Not",
                        "operand" : {
                           "locator" : "76:8-76:42",
                           "type" : "IsNull",
                           "operand" : {
                              "localId" : "110",
                              "locator" : "76:8-76:30",
                              "path" : "value",
                              "scope" : "FecalOccultResult",
                              "type" : "Property"
                           }
                        }
                     } ]
                  }, {
                     "localId" : "118",
                     "locator" : "77:8-77:98",
                     "precision" : "Day",
                     "type" : "IncludedIn",
                     "operand" : [ {
                        "localId" : "116",
                        "locator" : "77:8-77:63",
                        "name" : "Normalize Interval",
                        "libraryName" : "Global",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "115",
                           "locator" : "77:36-77:62",
                           "path" : "effective",
                           "scope" : "FecalOccultResult",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "117",
                        "locator" : "77:79-77:98",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "146",
            "locator" : "79:1-83:123",
            "name" : "Fecal Immunochemical Test DNA",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "146",
                  "s" : [ {
                     "value" : [ "define ","\"Fecal Immunochemical Test DNA\"",":\r\n\t" ]
                  }, {
                     "r" : "145",
                     "s" : [ {
                        "s" : [ {
                           "r" : "123",
                           "s" : [ {
                              "r" : "122",
                              "s" : [ {
                                 "r" : "122",
                                 "s" : [ {
                                    "value" : [ "[","Observation",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"FIT DNA\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","FitDNA" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "144",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "144",
                           "s" : [ {
                              "r" : "135",
                              "s" : [ {
                                 "r" : "131",
                                 "s" : [ {
                                    "r" : "125",
                                    "s" : [ {
                                       "r" : "124",
                                       "s" : [ {
                                          "value" : [ "FitDNA" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "125",
                                       "s" : [ {
                                          "value" : [ "status" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " in " ]
                                 }, {
                                    "r" : "130",
                                    "s" : [ {
                                       "value" : [ "{" ]
                                    }, {
                                       "r" : "126",
                                       "s" : [ {
                                          "value" : [ "'final'" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "127",
                                       "s" : [ {
                                          "value" : [ "'amended'" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "128",
                                       "s" : [ {
                                          "value" : [ "'corrected'" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "129",
                                       "s" : [ {
                                          "value" : [ "'preliminary'" ]
                                       } ]
                                    }, {
                                       "value" : [ "}" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n\t\t\tand " ]
                              }, {
                                 "r" : "134",
                                 "s" : [ {
                                    "r" : "133",
                                    "s" : [ {
                                       "r" : "132",
                                       "s" : [ {
                                          "value" : [ "FitDNA" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "133",
                                       "s" : [ {
                                          "value" : [ "value" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " is not null" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\t\t\tand " ]
                           }, {
                              "r" : "143",
                              "s" : [ {
                                 "r" : "139",
                                 "s" : [ {
                                    "r" : "136",
                                    "s" : [ {
                                       "value" : [ "Global" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "139",
                                    "s" : [ {
                                       "value" : [ "\"Normalize Interval\"","(" ]
                                    }, {
                                       "r" : "138",
                                       "s" : [ {
                                          "r" : "137",
                                          "s" : [ {
                                             "value" : [ "FitDNA" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "138",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "143",
                                 "s" : [ {
                                    "value" : [ "occurs " ]
                                 }, {
                                    "r" : "142",
                                    "s" : [ {
                                       "value" : [ "3 ","years" ]
                                    } ]
                                 }, {
                                    "value" : [ " or less on or before day of" ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "141",
                                 "s" : [ {
                                    "value" : [ "end of " ]
                                 }, {
                                    "r" : "140",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "145",
               "locator" : "80:2-83:123",
               "type" : "Query",
               "source" : [ {
                  "localId" : "123",
                  "locator" : "80:2-80:32",
                  "alias" : "FitDNA",
                  "expression" : {
                     "localId" : "122",
                     "locator" : "80:2-80:25",
                     "dataType" : "{http://hl7.org/fhir}Observation",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Observation",
                     "codeProperty" : "code",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "80:16-80:24",
                        "name" : "FIT DNA",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "144",
                  "locator" : "81:3-83:123",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "135",
                     "locator" : "81:9-82:31",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "131",
                        "locator" : "81:9-81:73",
                        "type" : "In",
                        "operand" : [ {
                           "name" : "ToString",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "125",
                              "locator" : "81:9-81:21",
                              "path" : "status",
                              "scope" : "FitDNA",
                              "type" : "Property"
                           } ]
                        }, {
                           "localId" : "130",
                           "locator" : "81:26-81:73",
                           "type" : "List",
                           "element" : [ {
                              "localId" : "126",
                              "locator" : "81:27-81:33",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "final",
                              "type" : "Literal"
                           }, {
                              "localId" : "127",
                              "locator" : "81:36-81:44",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "amended",
                              "type" : "Literal"
                           }, {
                              "localId" : "128",
                              "locator" : "81:47-81:57",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "corrected",
                              "type" : "Literal"
                           }, {
                              "localId" : "129",
                              "locator" : "81:60-81:72",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "preliminary",
                              "type" : "Literal"
                           } ]
                        } ]
                     }, {
                        "localId" : "134",
                        "locator" : "82:8-82:31",
                        "type" : "Not",
                        "operand" : {
                           "locator" : "82:8-82:31",
                           "type" : "IsNull",
                           "operand" : {
                              "localId" : "133",
                              "locator" : "82:8-82:19",
                              "path" : "value",
                              "scope" : "FitDNA",
                              "type" : "Property"
                           }
                        }
                     } ]
                  }, {
                     "localId" : "143",
                     "locator" : "83:8-83:123",
                     "type" : "And",
                     "operand" : [ {
                        "locator" : "83:61-83:75",
                        "precision" : "Day",
                        "type" : "In",
                        "operand" : [ {
                           "locator" : "83:15-83:52",
                           "type" : "End",
                           "operand" : {
                              "localId" : "139",
                              "locator" : "83:8-83:52",
                              "name" : "Normalize Interval",
                              "libraryName" : "Global",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "138",
                                 "locator" : "83:36-83:51",
                                 "path" : "effective",
                                 "scope" : "FitDNA",
                                 "type" : "Property"
                              } ]
                           }
                        }, {
                           "locator" : "83:61-83:75",
                           "lowClosed" : true,
                           "highClosed" : true,
                           "type" : "Interval",
                           "low" : {
                              "locator" : "83:97-83:123",
                              "type" : "Subtract",
                              "operand" : [ {
                                 "localId" : "141",
                                 "locator" : "83:97-83:123",
                                 "type" : "End",
                                 "operand" : {
                                    "localId" : "140",
                                    "locator" : "83:104-83:123",
                                    "name" : "Measurement Period",
                                    "type" : "ParameterRef"
                                 }
                              }, {
                                 "localId" : "142",
                                 "locator" : "83:61-83:67",
                                 "value" : 3,
                                 "unit" : "years",
                                 "type" : "Quantity"
                              } ]
                           },
                           "high" : {
                              "localId" : "141",
                              "locator" : "83:97-83:123",
                              "type" : "End",
                              "operand" : {
                                 "localId" : "140",
                                 "locator" : "83:104-83:123",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "locator" : "83:61-83:75",
                        "type" : "Not",
                        "operand" : {
                           "locator" : "83:61-83:75",
                           "type" : "IsNull",
                           "operand" : {
                              "localId" : "141",
                              "locator" : "83:97-83:123",
                              "type" : "End",
                              "operand" : {
                                 "localId" : "140",
                                 "locator" : "83:104-83:123",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        }
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "163",
            "locator" : "85:1-88:121",
            "name" : "Colonoscopy Performed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "163",
                  "s" : [ {
                     "value" : [ "define ","\"Colonoscopy Performed\"",":\r\n\t" ]
                  }, {
                     "r" : "162",
                     "s" : [ {
                        "s" : [ {
                           "r" : "148",
                           "s" : [ {
                              "r" : "147",
                              "s" : [ {
                                 "r" : "147",
                                 "s" : [ {
                                    "value" : [ "[","Procedure",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"Colonoscopy\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","Colonoscopy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "161",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "161",
                           "s" : [ {
                              "r" : "152",
                              "s" : [ {
                                 "r" : "150",
                                 "s" : [ {
                                    "r" : "149",
                                    "s" : [ {
                                       "value" : [ "Colonoscopy" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "150",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "151",
                                 "s" : [ {
                                    "value" : [ "'completed'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\t\t  and " ]
                           }, {
                              "r" : "160",
                              "s" : [ {
                                 "r" : "156",
                                 "s" : [ {
                                    "r" : "153",
                                    "s" : [ {
                                       "value" : [ "Global" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "156",
                                    "s" : [ {
                                       "value" : [ "\"Normalize Interval\"","(" ]
                                    }, {
                                       "r" : "155",
                                       "s" : [ {
                                          "r" : "154",
                                          "s" : [ {
                                             "value" : [ "Colonoscopy" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "155",
                                          "s" : [ {
                                             "value" : [ "performed" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "160",
                                 "s" : [ {
                                    "value" : [ "ends " ]
                                 }, {
                                    "r" : "159",
                                    "s" : [ {
                                       "value" : [ "10 ","years" ]
                                    } ]
                                 }, {
                                    "value" : [ " or less on or before" ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "158",
                                 "s" : [ {
                                    "value" : [ "end of " ]
                                 }, {
                                    "r" : "157",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "162",
               "locator" : "86:2-88:121",
               "type" : "Query",
               "source" : [ {
                  "localId" : "148",
                  "locator" : "86:2-86:39",
                  "alias" : "Colonoscopy",
                  "expression" : {
                     "localId" : "147",
                     "locator" : "86:2-86:27",
                     "dataType" : "{http://hl7.org/fhir}Procedure",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Procedure",
                     "codeProperty" : "code",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "86:14-86:26",
                        "name" : "Colonoscopy",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "161",
                  "locator" : "87:3-88:121",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "152",
                     "locator" : "87:9-87:40",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "150",
                           "locator" : "87:9-87:26",
                           "path" : "status",
                           "scope" : "Colonoscopy",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "151",
                        "locator" : "87:30-87:40",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "completed",
                        "type" : "Literal"
                     } ]
                  }, {
                     "localId" : "160",
                     "locator" : "88:9-88:121",
                     "type" : "And",
                     "operand" : [ {
                        "locator" : "88:65-88:80",
                        "type" : "In",
                        "operand" : [ {
                           "locator" : "88:60-88:63",
                           "type" : "End",
                           "operand" : {
                              "localId" : "156",
                              "locator" : "88:9-88:58",
                              "name" : "Normalize Interval",
                              "libraryName" : "Global",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "155",
                                 "locator" : "88:37-88:57",
                                 "path" : "performed",
                                 "scope" : "Colonoscopy",
                                 "type" : "Property"
                              } ]
                           }
                        }, {
                           "locator" : "88:65-88:80",
                           "lowClosed" : true,
                           "highClosed" : true,
                           "type" : "Interval",
                           "low" : {
                              "locator" : "88:95-88:121",
                              "type" : "Subtract",
                              "operand" : [ {
                                 "localId" : "158",
                                 "locator" : "88:95-88:121",
                                 "type" : "End",
                                 "operand" : {
                                    "localId" : "157",
                                    "locator" : "88:102-88:121",
                                    "name" : "Measurement Period",
                                    "type" : "ParameterRef"
                                 }
                              }, {
                                 "localId" : "159",
                                 "locator" : "88:65-88:72",
                                 "value" : 10,
                                 "unit" : "years",
                                 "type" : "Quantity"
                              } ]
                           },
                           "high" : {
                              "localId" : "158",
                              "locator" : "88:95-88:121",
                              "type" : "End",
                              "operand" : {
                                 "localId" : "157",
                                 "locator" : "88:102-88:121",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "locator" : "88:65-88:80",
                        "type" : "Not",
                        "operand" : {
                           "locator" : "88:65-88:80",
                           "type" : "IsNull",
                           "operand" : {
                              "localId" : "158",
                              "locator" : "88:95-88:121",
                              "type" : "End",
                              "operand" : {
                                 "localId" : "157",
                                 "locator" : "88:102-88:121",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        }
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "178",
            "locator" : "90:1-95:39",
            "name" : "Numerator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "178",
                  "s" : [ {
                     "value" : [ "define ","\"Numerator\"",":\r\n\t" ]
                  }, {
                     "r" : "177",
                     "s" : [ {
                        "r" : "174",
                        "s" : [ {
                           "r" : "171",
                           "s" : [ {
                              "r" : "168",
                              "s" : [ {
                                 "r" : "165",
                                 "s" : [ {
                                    "value" : [ "exists " ]
                                 }, {
                                    "r" : "164",
                                    "s" : [ {
                                       "value" : [ "\"Colonoscopy Performed\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n\t\tor " ]
                              }, {
                                 "r" : "167",
                                 "s" : [ {
                                    "value" : [ "exists " ]
                                 }, {
                                    "r" : "166",
                                    "s" : [ {
                                       "value" : [ "\"Fecal Occult Blood Test Performed\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\t\tor " ]
                           }, {
                              "r" : "170",
                              "s" : [ {
                                 "value" : [ "exists " ]
                              }, {
                                 "r" : "169",
                                 "s" : [ {
                                    "value" : [ "\"Flexible Sigmoidoscopy Performed\"" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\tor " ]
                        }, {
                           "r" : "173",
                           "s" : [ {
                              "value" : [ "exists " ]
                           }, {
                              "r" : "172",
                              "s" : [ {
                                 "value" : [ "\"Fecal Immunochemical Test DNA\"" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\tor " ]
                     }, {
                        "r" : "176",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "175",
                           "s" : [ {
                              "value" : [ "\"CT Colonography Performed\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "177",
               "locator" : "91:2-95:39",
               "type" : "Or",
               "operand" : [ {
                  "localId" : "174",
                  "locator" : "91:2-94:43",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "171",
                     "locator" : "91:2-93:46",
                     "type" : "Or",
                     "operand" : [ {
                        "localId" : "168",
                        "locator" : "91:2-92:47",
                        "type" : "Or",
                        "operand" : [ {
                           "localId" : "165",
                           "locator" : "91:2-91:31",
                           "type" : "Exists",
                           "operand" : {
                              "localId" : "164",
                              "locator" : "91:9-91:31",
                              "name" : "Colonoscopy Performed",
                              "type" : "ExpressionRef"
                           }
                        }, {
                           "localId" : "167",
                           "locator" : "92:6-92:47",
                           "type" : "Exists",
                           "operand" : {
                              "localId" : "166",
                              "locator" : "92:13-92:47",
                              "name" : "Fecal Occult Blood Test Performed",
                              "type" : "ExpressionRef"
                           }
                        } ]
                     }, {
                        "localId" : "170",
                        "locator" : "93:6-93:46",
                        "type" : "Exists",
                        "operand" : {
                           "localId" : "169",
                           "locator" : "93:13-93:46",
                           "name" : "Flexible Sigmoidoscopy Performed",
                           "type" : "ExpressionRef"
                        }
                     } ]
                  }, {
                     "localId" : "173",
                     "locator" : "94:6-94:43",
                     "type" : "Exists",
                     "operand" : {
                        "localId" : "172",
                        "locator" : "94:13-94:43",
                        "name" : "Fecal Immunochemical Test DNA",
                        "type" : "ExpressionRef"
                     }
                  } ]
               }, {
                  "localId" : "176",
                  "locator" : "95:6-95:39",
                  "type" : "Exists",
                  "operand" : {
                     "localId" : "175",
                     "locator" : "95:13-95:39",
                     "name" : "CT Colonography Performed",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "187",
            "locator" : "97:1-100:39",
            "name" : "Denominator Exclusion",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "187",
                  "s" : [ {
                     "value" : [ "define ","\"Denominator Exclusion\"",":\r\n\t" ]
                  }, {
                     "r" : "186",
                     "s" : [ {
                        "r" : "183",
                        "s" : [ {
                           "r" : "180",
                           "s" : [ {
                              "r" : "179",
                              "s" : [ {
                                 "value" : [ "Hospice" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "180",
                              "s" : [ {
                                 "value" : [ "\"Has Hospice\"" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\tor " ]
                        }, {
                           "r" : "182",
                           "s" : [ {
                              "value" : [ "exists " ]
                           }, {
                              "r" : "181",
                              "s" : [ {
                                 "value" : [ "\"Malignant Neoplasm Ever\"" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\tor " ]
                     }, {
                        "r" : "185",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "184",
                           "s" : [ {
                              "value" : [ "\"Total Colectomy Performed\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "186",
               "locator" : "98:2-100:39",
               "type" : "Or",
               "operand" : [ {
                  "localId" : "183",
                  "locator" : "98:2-99:37",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "180",
                     "locator" : "98:2-98:22",
                     "name" : "Has Hospice",
                     "libraryName" : "Hospice",
                     "type" : "ExpressionRef"
                  }, {
                     "localId" : "182",
                     "locator" : "99:6-99:37",
                     "type" : "Exists",
                     "operand" : {
                        "localId" : "181",
                        "locator" : "99:13-99:37",
                        "name" : "Malignant Neoplasm Ever",
                        "type" : "ExpressionRef"
                     }
                  } ]
               }, {
                  "localId" : "185",
                  "locator" : "100:6-100:39",
                  "type" : "Exists",
                  "operand" : {
                     "localId" : "184",
                     "locator" : "100:13-100:39",
                     "name" : "Total Colectomy Performed",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "204",
            "locator" : "102:1-104:63",
            "name" : "Initial Population",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "204",
                  "s" : [ {
                     "value" : [ "define ","\"Initial Population\"",":\r\n\t" ]
                  }, {
                     "r" : "203",
                     "s" : [ {
                        "r" : "199",
                        "s" : [ {
                           "r" : "195",
                           "s" : [ {
                              "r" : "188",
                              "s" : [ {
                                 "value" : [ "Global" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "195",
                              "s" : [ {
                                 "value" : [ "\"CalendarAgeInYearsAt\"","(" ]
                              }, {
                                 "r" : "192",
                                 "s" : [ {
                                    "r" : "189",
                                    "s" : [ {
                                       "value" : [ "FHIRHelpers" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "192",
                                    "s" : [ {
                                       "value" : [ "ToDate","(" ]
                                    }, {
                                       "r" : "191",
                                       "s" : [ {
                                          "r" : "190",
                                          "s" : [ {
                                             "value" : [ "Patient" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "191",
                                          "s" : [ {
                                             "value" : [ "birthDate" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "194",
                                 "s" : [ {
                                    "value" : [ "start of " ]
                                 }, {
                                    "r" : "193",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " in " ]
                        }, {
                           "r" : "198",
                           "s" : [ {
                              "r" : "196",
                              "value" : [ "Interval[","50",", ","75","]" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t\tand " ]
                     }, {
                        "r" : "202",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "201",
                           "s" : [ {
                              "r" : "200",
                              "s" : [ {
                                 "value" : [ "AdultOutpatientEncounters" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "201",
                              "s" : [ {
                                 "value" : [ "\"Qualifying Encounters\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "203",
               "locator" : "103:2-104:63",
               "type" : "And",
               "operand" : [ {
                  "localId" : "199",
                  "locator" : "103:2-103:120",
                  "type" : "In",
                  "operand" : [ {
                     "localId" : "195",
                     "locator" : "103:2-103:100",
                     "name" : "CalendarAgeInYearsAt",
                     "libraryName" : "Global",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "type" : "ToDateTime",
                        "operand" : {
                           "localId" : "192",
                           "locator" : "103:32-103:68",
                           "name" : "ToDate",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "191",
                              "locator" : "103:51-103:67",
                              "path" : "birthDate",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "190",
                                 "locator" : "103:51-103:57",
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           } ]
                        }
                     }, {
                        "localId" : "194",
                        "locator" : "103:71-103:99",
                        "type" : "Start",
                        "operand" : {
                           "localId" : "193",
                           "locator" : "103:80-103:99",
                           "name" : "Measurement Period",
                           "type" : "ParameterRef"
                        }
                     } ]
                  }, {
                     "localId" : "198",
                     "locator" : "103:105-103:120",
                     "lowClosed" : true,
                     "highClosed" : true,
                     "type" : "Interval",
                     "low" : {
                        "localId" : "196",
                        "locator" : "103:114-103:115",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "50",
                        "type" : "Literal"
                     },
                     "high" : {
                        "localId" : "197",
                        "locator" : "103:118-103:119",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "75",
                        "type" : "Literal"
                     }
                  } ]
               }, {
                  "localId" : "202",
                  "locator" : "104:8-104:63",
                  "type" : "Exists",
                  "operand" : {
                     "localId" : "201",
                     "locator" : "104:15-104:63",
                     "name" : "Qualifying Encounters",
                     "libraryName" : "AdultOutpatientEncounters",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         } ]
      }
   }
}" + } ] + }, + "request": { + "method": "PUT", + "url": "Library/library-EXM130-7.3.000" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113762.1.4.1111.143", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1111.143", + "title": "Observation Services", + "status": "active", + "publisher": "The Joint Commission", + "compose": { + "include": [ { + "system": "http://snomed.info/sct", + "version": "2019-09", + "concept": [ { + "code": "448851000124103", + "display": "Hospital admission from observation unit (procedure)" + }, { + "code": "448951000124107", + "display": "Admission to observation unit (procedure)" + }, { + "code": "76464004", + "display": "Hospital admission, for observation (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113762.1.4.1111.143" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.108.12.1038", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1038", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.108.12.1038" + } ], + "version": "20171219", + "name": "CTColonography", + "title": "CT Colonography", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.ama-assn.org/go/cpt", + "version": "2018", + "concept": [ { + "code": "74261", + "display": "Computed tomographic (CT) colonography, diagnostic, including image postprocessing; without contrast material" + }, { + "code": "74262", + "display": "Computed tomographic (CT) colonography, diagnostic, including image postprocessing; with contrast material(s) including non-contrast images, if performed" + }, { + "code": "74263", + "display": "Computed tomographic (CT) colonography, screening, including image postprocessing" + } ] + }, { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "418714002", + "display": "Virtual computed tomography colonoscopy (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.108.12.1038" + } + }, { + "resource": { + "resourceType": "Library", + "id": "library-SupplementalDataElements-2.0.0", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "#cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/dbcg/connectathon/Library/SupplementalDataElements", + "version": "2.0.0", + "name": "SupplementalDataElements", + "status": "active", + "experimental": true, + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } ] + }, + "relatedArtifact": [ { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIRHelpers|4.0.1" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.836" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.837" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } ], + "parameter": [ { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Patient" + }, { + "name": "SDE Ethnicity", + "use": "out", + "min": 0, + "max": "*", + "type": "Coding" + }, { + "name": "SDE Payer", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "SDE Race", + "use": "out", + "min": 0, + "max": "*", + "type": "Coding" + }, { + "name": "SDE Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + } ], + "dataRequirement": [ { + "type": "Coverage", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Coverage" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } ] + } ], + "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 translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <identifier id="SupplementalDataElements" system="http://fhir.org/guides/dbcg/connectathon" version="2.0.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:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1"/>
   </usings>
   <includes>
      <def localId="2" locator="5:1-5:54" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/dbcg/connectathon/FHIRHelpers" version="4.0.1"/>
   </includes>
   <valueSets>
      <def localId="3" locator="7:1-7:97" name="ONC Administrative Sex" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1" accessLevel="Public"/>
      <def localId="4" locator="8:1-8:82" name="Race" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.836" accessLevel="Public"/>
      <def localId="5" locator="9:1-9:87" name="Ethnicity" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.837" accessLevel="Public"/>
      <def localId="6" locator="10:1-10:84" name="Payer" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" accessLevel="Public"/>
   </valueSets>
   <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/StructureDefinition/Patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="34" locator="14:1-22:28" name="SDE Ethnicity" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="34">
               <a:s>define &quot;SDE Ethnicity&quot;:&#xd;
  </a:s>
               <a:s r="33">
                  <a:s>
                     <a:s r="18">
                        <a:s r="17">
                           <a:s>(</a:s>
                           <a:s r="17">
                              <a:s>flatten </a:s>
                              <a:s r="16">
                                 <a:s>(&#xd;
    </a:s>
                                 <a:s r="16">
                                    <a:s>
                                       <a:s r="8">
                                          <a:s r="7">
                                             <a:s>
                                                <a:s>Patient.extension</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> Extension</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>&#xd;
      </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>Extension</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="10">
                                                <a:s>url</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> = </a:s>
                                          <a:s r="11">
                                             <a:s>'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity'</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>&#xd;
        </a:s>
                                    <a:s r="15">
                                       <a:s>return </a:s>
                                       <a:s r="14">
                                          <a:s r="13">
                                             <a:s>Extension</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="14">
                                             <a:s>extension</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
  )</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                        <a:s> E</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
    </a:s>
                  <a:s r="27">
                     <a:s>where </a:s>
                     <a:s r="27">
                        <a:s r="22">
                           <a:s r="20">
                              <a:s r="19">
                                 <a:s>E</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="20">
                                 <a:s>url</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="21">
                              <a:s>'ombCategory'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
      or </a:s>
                        <a:s r="26">
                           <a:s r="24">
                              <a:s r="23">
                                 <a:s>E</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="24">
                                 <a:s>url</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="25">
                              <a:s>'detailed'</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
    </a:s>
                  <a:s r="32">
                     <a:s>return </a:s>
                     <a:s r="31">
                        <a:s r="29">
                           <a:s r="28">
                              <a:s>E</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="29">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s> as </a:s>
                        <a:s r="30">
                           <a:s>Coding</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="33" locator="15:3-22:28" xsi:type="Query">
            <source localId="18" locator="15:3-19:6" alias="E">
               <expression localId="17" locator="15:3-19:4" xsi:type="Flatten">
                  <operand localId="16" locator="15:12-19:3" xsi:type="Query">
                     <source localId="8" locator="16:5-16:31" alias="Extension">
                        <expression localId="7" locator="16:5-16:21" path="extension" xsi:type="Property">
                           <source name="Patient" xsi:type="ExpressionRef"/>
                        </expression>
                     </source>
                     <where localId="12" locator="17:7-17:95" xsi:type="Equal">
                        <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="10" locator="17:13-17:25" path="url" scope="Extension" xsi:type="Property"/>
                        </operand>
                        <operand localId="11" locator="17:29-17:95" valueType="t:String" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity" xsi:type="Literal"/>
                     </where>
                     <return localId="15" locator="18:9-18:34">
                        <expression localId="14" locator="18:16-18:34" path="extension" scope="Extension" xsi:type="Property"/>
                     </return>
                  </operand>
               </expression>
            </source>
            <where localId="27" locator="20:5-21:27" xsi:type="Or">
               <operand localId="22" locator="20:11-20:31" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="20" locator="20:11-20:15" path="url" scope="E" xsi:type="Property"/>
                  </operand>
                  <operand localId="21" locator="20:19-20:31" valueType="t:String" value="ombCategory" xsi:type="Literal"/>
               </operand>
               <operand localId="26" locator="21:10-21:27" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="24" locator="21:10-21:14" path="url" scope="E" xsi:type="Property"/>
                  </operand>
                  <operand localId="25" locator="21:18-21:27" valueType="t:String" value="detailed" xsi:type="Literal"/>
               </operand>
            </where>
            <return localId="32" locator="22:5-22:28">
               <expression localId="31" locator="22:12-22:28" strict="false" xsi:type="As">
                  <operand localId="29" locator="22:12-22:18" path="value" scope="E" xsi:type="Property"/>
                  <asTypeSpecifier localId="30" locator="22:23-22:28" name="fhir:Coding" xsi:type="NamedTypeSpecifier"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="44" locator="24:1-29:7" name="SDE Payer" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="44">
               <a:s>define &quot;SDE Payer&quot;:&#xd;
    </a:s>
               <a:s r="43">
                  <a:s>
                     <a:s r="36">
                        <a:s r="35">
                           <a:s r="35">
                              <a:s>[Coverage: </a:s>
                              <a:s>
                                 <a:s>type</a:s>
                              </a:s>
                              <a:s> in </a:s>
                              <a:s>
                                 <a:s>&quot;Payer&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> Payer</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
      </a:s>
                  <a:s r="42">
                     <a:s>return </a:s>
                     <a:s r="41">
                        <a:s>{&#xd;
        </a:s>
                        <a:s>
                           <a:s>code: </a:s>
                           <a:s r="38">
                              <a:s r="37">
                                 <a:s>Payer</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="38">
                                 <a:s>type</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,&#xd;
        </a:s>
                        <a:s>
                           <a:s>period: </a:s>
                           <a:s r="40">
                              <a:s r="39">
                                 <a:s>Payer</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="40">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
      }</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="43" locator="25:5-29:7" xsi:type="Query">
            <source localId="36" locator="25:5-25:37" alias="Payer">
               <expression localId="35" locator="25:5-25:31" dataType="fhir:Coverage" templateId="http://hl7.org/fhir/StructureDefinition/Coverage" codeProperty="type" xsi:type="Retrieve">
                  <codes locator="25:24-25:30" name="Payer" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <return localId="42" locator="26:7-29:7">
               <expression localId="41" locator="26:14-29:7" xsi:type="Tuple">
                  <element name="code">
                     <value localId="38" locator="27:15-27:24" path="type" scope="Payer" xsi:type="Property"/>
                  </element>
                  <element name="period">
                     <value localId="40" locator="28:17-28:28" path="period" scope="Payer" xsi:type="Property"/>
                  </element>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="72" locator="31:1-39:28" name="SDE Race" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="72">
               <a:s>define &quot;SDE Race&quot;:&#xd;
  </a:s>
               <a:s r="71">
                  <a:s>
                     <a:s r="56">
                        <a:s r="55">
                           <a:s>(</a:s>
                           <a:s r="55">
                              <a:s>flatten </a:s>
                              <a:s r="54">
                                 <a:s>(&#xd;
    </a:s>
                                 <a:s r="54">
                                    <a:s>
                                       <a:s r="46">
                                          <a:s r="45">
                                             <a:s>
                                                <a:s>Patient.extension</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> Extension</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>&#xd;
      </a:s>
                                    <a:s r="50">
                                       <a:s>where </a:s>
                                       <a:s r="50">
                                          <a:s r="48">
                                             <a:s r="47">
                                                <a:s>Extension</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="48">
                                                <a:s>url</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> = </a:s>
                                          <a:s r="49">
                                             <a:s>'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race'</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>&#xd;
        </a:s>
                                    <a:s r="53">
                                       <a:s>return </a:s>
                                       <a:s r="52">
                                          <a:s r="51">
                                             <a:s>Extension</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="52">
                                             <a:s>extension</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
  )</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                        <a:s> E</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
    </a:s>
                  <a:s r="65">
                     <a:s>where </a:s>
                     <a:s r="65">
                        <a:s r="60">
                           <a:s r="58">
                              <a:s r="57">
                                 <a:s>E</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="58">
                                 <a:s>url</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="59">
                              <a:s>'ombCategory'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
      or </a:s>
                        <a:s r="64">
                           <a:s r="62">
                              <a:s r="61">
                                 <a:s>E</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="62">
                                 <a:s>url</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="63">
                              <a:s>'detailed'</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
    </a:s>
                  <a:s r="70">
                     <a:s>return </a:s>
                     <a:s r="69">
                        <a:s r="67">
                           <a:s r="66">
                              <a:s>E</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="67">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s> as </a:s>
                        <a:s r="68">
                           <a:s>Coding</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="71" locator="32:3-39:28" xsi:type="Query">
            <source localId="56" locator="32:3-36:6" alias="E">
               <expression localId="55" locator="32:3-36:4" xsi:type="Flatten">
                  <operand localId="54" locator="32:12-36:3" xsi:type="Query">
                     <source localId="46" locator="33:5-33:31" alias="Extension">
                        <expression localId="45" locator="33:5-33:21" path="extension" xsi:type="Property">
                           <source name="Patient" xsi:type="ExpressionRef"/>
                        </expression>
                     </source>
                     <where localId="50" locator="34:7-34:90" xsi:type="Equal">
                        <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="48" locator="34:13-34:25" path="url" scope="Extension" xsi:type="Property"/>
                        </operand>
                        <operand localId="49" locator="34:29-34:90" valueType="t:String" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-race" xsi:type="Literal"/>
                     </where>
                     <return localId="53" locator="35:9-35:34">
                        <expression localId="52" locator="35:16-35:34" path="extension" scope="Extension" xsi:type="Property"/>
                     </return>
                  </operand>
               </expression>
            </source>
            <where localId="65" locator="37:5-38:27" xsi:type="Or">
               <operand localId="60" locator="37:11-37:31" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="58" locator="37:11-37:15" path="url" scope="E" xsi:type="Property"/>
                  </operand>
                  <operand localId="59" locator="37:19-37:31" valueType="t:String" value="ombCategory" xsi:type="Literal"/>
               </operand>
               <operand localId="64" locator="38:10-38:27" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="62" locator="38:10-38:14" path="url" scope="E" xsi:type="Property"/>
                  </operand>
                  <operand localId="63" locator="38:18-38:27" valueType="t:String" value="detailed" xsi:type="Literal"/>
               </operand>
            </where>
            <return localId="70" locator="39:5-39:28">
               <expression localId="69" locator="39:12-39:28" strict="false" xsi:type="As">
                  <operand localId="67" locator="39:12-39:18" path="value" scope="E" xsi:type="Property"/>
                  <asTypeSpecifier localId="68" locator="39:23-39:28" name="fhir:Coding" xsi:type="NamedTypeSpecifier"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="93" locator="41:1-46:5" name="SDE Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="93">
               <a:s>define &quot;SDE Sex&quot;:&#xd;
  </a:s>
               <a:s r="92">
                  <a:s>case&#xd;
    </a:s>
                  <a:s r="81">
                     <a:s>when </a:s>
                     <a:s r="76">
                        <a:s r="74">
                           <a:s r="73">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="74">
                              <a:s>gender</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="75">
                           <a:s>'male'</a:s>
                        </a:s>
                     </a:s>
                     <a:s> then </a:s>
                     <a:s r="80">
                        <a:s>Code { </a:s>
                        <a:s>
                           <a:s>code: </a:s>
                           <a:s r="77">
                              <a:s>'M'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s>
                           <a:s>system: </a:s>
                           <a:s r="78">
                              <a:s>'http://hl7.org/fhir/v3/AdministrativeGender'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s>
                           <a:s>display: </a:s>
                           <a:s r="79">
                              <a:s>'Male'</a:s>
                           </a:s>
                        </a:s>
                        <a:s> }</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
    </a:s>
                  <a:s r="90">
                     <a:s>when </a:s>
                     <a:s r="85">
                        <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>gender</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="84">
                           <a:s>'female'</a:s>
                        </a:s>
                     </a:s>
                     <a:s> then </a:s>
                     <a:s r="89">
                        <a:s>Code { </a:s>
                        <a:s>
                           <a:s>code: </a:s>
                           <a:s r="86">
                              <a:s>'F'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s>
                           <a:s>system: </a:s>
                           <a:s r="87">
                              <a:s>'http://hl7.org/fhir/v3/AdministrativeGender'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s>
                           <a:s>display: </a:s>
                           <a:s r="88">
                              <a:s>'Female'</a:s>
                           </a:s>
                        </a:s>
                        <a:s> }</a:s>
                     </a:s>
                  </a:s>
                  <a:s r="91">&#xd;
    else null&#xd;
  end</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="92" locator="42:3-46:5" xsi:type="Case">
            <caseItem localId="81" locator="43:5-43:128">
               <when localId="76" locator="43:10-43:32" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="74" locator="43:10-43:23" path="gender" xsi:type="Property">
                        <source localId="73" locator="43:10-43:16" name="Patient" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
                  <operand localId="75" locator="43:27-43:32" valueType="t:String" value="male" xsi:type="Literal"/>
               </when>
               <then localId="80" locator="43:39-43:128" classType="t:Code" xsi:type="Instance">
                  <element name="code">
                     <value localId="77" locator="43:52-43:54" valueType="t:String" value="M" xsi:type="Literal"/>
                  </element>
                  <element name="system">
                     <value localId="78" locator="43:65-43:109" valueType="t:String" value="http://hl7.org/fhir/v3/AdministrativeGender" xsi:type="Literal"/>
                  </element>
                  <element name="display">
                     <value localId="79" locator="43:121-43:126" valueType="t:String" value="Male" xsi:type="Literal"/>
                  </element>
               </then>
            </caseItem>
            <caseItem localId="90" locator="44:5-44:132">
               <when localId="85" locator="44:10-44:34" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="83" locator="44:10-44:23" path="gender" xsi:type="Property">
                        <source localId="82" locator="44:10-44:16" name="Patient" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
                  <operand localId="84" locator="44:27-44:34" valueType="t:String" value="female" xsi:type="Literal"/>
               </when>
               <then localId="89" locator="44:41-44:132" classType="t:Code" xsi:type="Instance">
                  <element name="code">
                     <value localId="86" locator="44:54-44:56" valueType="t:String" value="F" xsi:type="Literal"/>
                  </element>
                  <element name="system">
                     <value localId="87" locator="44:67-44:111" valueType="t:String" value="http://hl7.org/fhir/v3/AdministrativeGender" xsi:type="Literal"/>
                  </element>
                  <element name="display">
                     <value localId="88" locator="44:123-44:130" valueType="t:String" value="Female" xsi:type="Literal"/>
                  </element>
               </then>
            </caseItem>
            <else asType="t:Code" xsi:type="As">
               <operand localId="91" locator="45:10-45:13" xsi:type="Null"/>
            </else>
         </expression>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      } ],
      "identifier" : {
         "id" : "SupplementalDataElements",
         "system" : "http://fhir.org/guides/dbcg/connectathon",
         "version" : "2.0.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:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1"
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "2",
            "locator" : "5:1-5:54",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/dbcg/connectathon/FHIRHelpers",
            "version" : "4.0.1"
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "3",
            "locator" : "7:1-7:97",
            "name" : "ONC Administrative Sex",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1",
            "accessLevel" : "Public"
         }, {
            "localId" : "4",
            "locator" : "8:1-8:82",
            "name" : "Race",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.836",
            "accessLevel" : "Public"
         }, {
            "localId" : "5",
            "locator" : "9:1-9:87",
            "name" : "Ethnicity",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.837",
            "accessLevel" : "Public"
         }, {
            "localId" : "6",
            "locator" : "10:1-10:84",
            "name" : "Payer",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591",
            "accessLevel" : "Public"
         } ]
      },
      "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/StructureDefinition/Patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "34",
            "locator" : "14:1-22:28",
            "name" : "SDE Ethnicity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "34",
                  "s" : [ {
                     "value" : [ "define ","\"SDE Ethnicity\"",":\r\n  " ]
                  }, {
                     "r" : "33",
                     "s" : [ {
                        "s" : [ {
                           "r" : "18",
                           "s" : [ {
                              "r" : "17",
                              "s" : [ {
                                 "value" : [ "(" ]
                              }, {
                                 "r" : "17",
                                 "s" : [ {
                                    "value" : [ "flatten " ]
                                 }, {
                                    "r" : "16",
                                    "s" : [ {
                                       "value" : [ "(\r\n    " ]
                                    }, {
                                       "r" : "16",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "8",
                                             "s" : [ {
                                                "r" : "7",
                                                "s" : [ {
                                                   "s" : [ {
                                                      "value" : [ "Patient",".","extension" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","Extension" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\r\n      " ]
                                       }, {
                                          "r" : "12",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "12",
                                             "s" : [ {
                                                "r" : "10",
                                                "s" : [ {
                                                   "r" : "9",
                                                   "s" : [ {
                                                      "value" : [ "Extension" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "10",
                                                   "s" : [ {
                                                      "value" : [ "url" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","="," " ]
                                             }, {
                                                "r" : "11",
                                                "s" : [ {
                                                   "value" : [ "'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity'" ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\r\n        " ]
                                       }, {
                                          "r" : "15",
                                          "s" : [ {
                                             "value" : [ "return " ]
                                          }, {
                                             "r" : "14",
                                             "s" : [ {
                                                "r" : "13",
                                                "s" : [ {
                                                   "value" : [ "Extension" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "14",
                                                "s" : [ {
                                                   "value" : [ "extension" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n  )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ " ","E" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n    " ]
                     }, {
                        "r" : "27",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "27",
                           "s" : [ {
                              "r" : "22",
                              "s" : [ {
                                 "r" : "20",
                                 "s" : [ {
                                    "r" : "19",
                                    "s" : [ {
                                       "value" : [ "E" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "20",
                                    "s" : [ {
                                       "value" : [ "url" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "21",
                                 "s" : [ {
                                    "value" : [ "'ombCategory'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n      or " ]
                           }, {
                              "r" : "26",
                              "s" : [ {
                                 "r" : "24",
                                 "s" : [ {
                                    "r" : "23",
                                    "s" : [ {
                                       "value" : [ "E" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "24",
                                    "s" : [ {
                                       "value" : [ "url" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "25",
                                 "s" : [ {
                                    "value" : [ "'detailed'" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n    " ]
                     }, {
                        "r" : "32",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "31",
                           "s" : [ {
                              "r" : "29",
                              "s" : [ {
                                 "r" : "28",
                                 "s" : [ {
                                    "value" : [ "E" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "29",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " as " ]
                           }, {
                              "r" : "30",
                              "s" : [ {
                                 "value" : [ "Coding" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "33",
               "locator" : "15:3-22:28",
               "type" : "Query",
               "source" : [ {
                  "localId" : "18",
                  "locator" : "15:3-19:6",
                  "alias" : "E",
                  "expression" : {
                     "localId" : "17",
                     "locator" : "15:3-19:4",
                     "type" : "Flatten",
                     "operand" : {
                        "localId" : "16",
                        "locator" : "15:12-19:3",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "8",
                           "locator" : "16:5-16:31",
                           "alias" : "Extension",
                           "expression" : {
                              "localId" : "7",
                              "locator" : "16:5-16:21",
                              "path" : "extension",
                              "type" : "Property",
                              "source" : {
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "12",
                           "locator" : "17:7-17:95",
                           "type" : "Equal",
                           "operand" : [ {
                              "name" : "ToString",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "10",
                                 "locator" : "17:13-17:25",
                                 "path" : "url",
                                 "scope" : "Extension",
                                 "type" : "Property"
                              } ]
                           }, {
                              "localId" : "11",
                              "locator" : "17:29-17:95",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity",
                              "type" : "Literal"
                           } ]
                        },
                        "return" : {
                           "localId" : "15",
                           "locator" : "18:9-18:34",
                           "expression" : {
                              "localId" : "14",
                              "locator" : "18:16-18:34",
                              "path" : "extension",
                              "scope" : "Extension",
                              "type" : "Property"
                           }
                        }
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "27",
                  "locator" : "20:5-21:27",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "22",
                     "locator" : "20:11-20:31",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "20",
                           "locator" : "20:11-20:15",
                           "path" : "url",
                           "scope" : "E",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "21",
                        "locator" : "20:19-20:31",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "ombCategory",
                        "type" : "Literal"
                     } ]
                  }, {
                     "localId" : "26",
                     "locator" : "21:10-21:27",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "24",
                           "locator" : "21:10-21:14",
                           "path" : "url",
                           "scope" : "E",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "25",
                        "locator" : "21:18-21:27",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "detailed",
                        "type" : "Literal"
                     } ]
                  } ]
               },
               "return" : {
                  "localId" : "32",
                  "locator" : "22:5-22:28",
                  "expression" : {
                     "localId" : "31",
                     "locator" : "22:12-22:28",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "29",
                        "locator" : "22:12-22:18",
                        "path" : "value",
                        "scope" : "E",
                        "type" : "Property"
                     },
                     "asTypeSpecifier" : {
                        "localId" : "30",
                        "locator" : "22:23-22:28",
                        "name" : "{http://hl7.org/fhir}Coding",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            }
         }, {
            "localId" : "44",
            "locator" : "24:1-29:7",
            "name" : "SDE Payer",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "44",
                  "s" : [ {
                     "value" : [ "define ","\"SDE Payer\"",":\r\n    " ]
                  }, {
                     "r" : "43",
                     "s" : [ {
                        "s" : [ {
                           "r" : "36",
                           "s" : [ {
                              "r" : "35",
                              "s" : [ {
                                 "r" : "35",
                                 "s" : [ {
                                    "value" : [ "[","Coverage",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "type" ]
                                    } ]
                                 }, {
                                    "value" : [ " in " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"Payer\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","Payer" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n      " ]
                     }, {
                        "r" : "42",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "41",
                           "s" : [ {
                              "value" : [ "{\r\n        " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "code",": " ]
                              }, {
                                 "r" : "38",
                                 "s" : [ {
                                    "r" : "37",
                                    "s" : [ {
                                       "value" : [ "Payer" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "38",
                                    "s" : [ {
                                       "value" : [ "type" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\r\n        " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "period",": " ]
                              }, {
                                 "r" : "40",
                                 "s" : [ {
                                    "r" : "39",
                                    "s" : [ {
                                       "value" : [ "Payer" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "40",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n      }" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "43",
               "locator" : "25:5-29:7",
               "type" : "Query",
               "source" : [ {
                  "localId" : "36",
                  "locator" : "25:5-25:37",
                  "alias" : "Payer",
                  "expression" : {
                     "localId" : "35",
                     "locator" : "25:5-25:31",
                     "dataType" : "{http://hl7.org/fhir}Coverage",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Coverage",
                     "codeProperty" : "type",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "25:24-25:30",
                        "name" : "Payer",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "42",
                  "locator" : "26:7-29:7",
                  "expression" : {
                     "localId" : "41",
                     "locator" : "26:14-29:7",
                     "type" : "Tuple",
                     "element" : [ {
                        "name" : "code",
                        "value" : {
                           "localId" : "38",
                           "locator" : "27:15-27:24",
                           "path" : "type",
                           "scope" : "Payer",
                           "type" : "Property"
                        }
                     }, {
                        "name" : "period",
                        "value" : {
                           "localId" : "40",
                           "locator" : "28:17-28:28",
                           "path" : "period",
                           "scope" : "Payer",
                           "type" : "Property"
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "72",
            "locator" : "31:1-39:28",
            "name" : "SDE Race",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "72",
                  "s" : [ {
                     "value" : [ "define ","\"SDE Race\"",":\r\n  " ]
                  }, {
                     "r" : "71",
                     "s" : [ {
                        "s" : [ {
                           "r" : "56",
                           "s" : [ {
                              "r" : "55",
                              "s" : [ {
                                 "value" : [ "(" ]
                              }, {
                                 "r" : "55",
                                 "s" : [ {
                                    "value" : [ "flatten " ]
                                 }, {
                                    "r" : "54",
                                    "s" : [ {
                                       "value" : [ "(\r\n    " ]
                                    }, {
                                       "r" : "54",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "46",
                                             "s" : [ {
                                                "r" : "45",
                                                "s" : [ {
                                                   "s" : [ {
                                                      "value" : [ "Patient",".","extension" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","Extension" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\r\n      " ]
                                       }, {
                                          "r" : "50",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "50",
                                             "s" : [ {
                                                "r" : "48",
                                                "s" : [ {
                                                   "r" : "47",
                                                   "s" : [ {
                                                      "value" : [ "Extension" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "48",
                                                   "s" : [ {
                                                      "value" : [ "url" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","="," " ]
                                             }, {
                                                "r" : "49",
                                                "s" : [ {
                                                   "value" : [ "'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race'" ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\r\n        " ]
                                       }, {
                                          "r" : "53",
                                          "s" : [ {
                                             "value" : [ "return " ]
                                          }, {
                                             "r" : "52",
                                             "s" : [ {
                                                "r" : "51",
                                                "s" : [ {
                                                   "value" : [ "Extension" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "52",
                                                "s" : [ {
                                                   "value" : [ "extension" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n  )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ " ","E" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n    " ]
                     }, {
                        "r" : "65",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "65",
                           "s" : [ {
                              "r" : "60",
                              "s" : [ {
                                 "r" : "58",
                                 "s" : [ {
                                    "r" : "57",
                                    "s" : [ {
                                       "value" : [ "E" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "58",
                                    "s" : [ {
                                       "value" : [ "url" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "59",
                                 "s" : [ {
                                    "value" : [ "'ombCategory'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n      or " ]
                           }, {
                              "r" : "64",
                              "s" : [ {
                                 "r" : "62",
                                 "s" : [ {
                                    "r" : "61",
                                    "s" : [ {
                                       "value" : [ "E" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "62",
                                    "s" : [ {
                                       "value" : [ "url" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "63",
                                 "s" : [ {
                                    "value" : [ "'detailed'" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n    " ]
                     }, {
                        "r" : "70",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "69",
                           "s" : [ {
                              "r" : "67",
                              "s" : [ {
                                 "r" : "66",
                                 "s" : [ {
                                    "value" : [ "E" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "67",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " as " ]
                           }, {
                              "r" : "68",
                              "s" : [ {
                                 "value" : [ "Coding" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "71",
               "locator" : "32:3-39:28",
               "type" : "Query",
               "source" : [ {
                  "localId" : "56",
                  "locator" : "32:3-36:6",
                  "alias" : "E",
                  "expression" : {
                     "localId" : "55",
                     "locator" : "32:3-36:4",
                     "type" : "Flatten",
                     "operand" : {
                        "localId" : "54",
                        "locator" : "32:12-36:3",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "46",
                           "locator" : "33:5-33:31",
                           "alias" : "Extension",
                           "expression" : {
                              "localId" : "45",
                              "locator" : "33:5-33:21",
                              "path" : "extension",
                              "type" : "Property",
                              "source" : {
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "50",
                           "locator" : "34:7-34:90",
                           "type" : "Equal",
                           "operand" : [ {
                              "name" : "ToString",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "48",
                                 "locator" : "34:13-34:25",
                                 "path" : "url",
                                 "scope" : "Extension",
                                 "type" : "Property"
                              } ]
                           }, {
                              "localId" : "49",
                              "locator" : "34:29-34:90",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race",
                              "type" : "Literal"
                           } ]
                        },
                        "return" : {
                           "localId" : "53",
                           "locator" : "35:9-35:34",
                           "expression" : {
                              "localId" : "52",
                              "locator" : "35:16-35:34",
                              "path" : "extension",
                              "scope" : "Extension",
                              "type" : "Property"
                           }
                        }
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "65",
                  "locator" : "37:5-38:27",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "60",
                     "locator" : "37:11-37:31",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "58",
                           "locator" : "37:11-37:15",
                           "path" : "url",
                           "scope" : "E",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "59",
                        "locator" : "37:19-37:31",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "ombCategory",
                        "type" : "Literal"
                     } ]
                  }, {
                     "localId" : "64",
                     "locator" : "38:10-38:27",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "62",
                           "locator" : "38:10-38:14",
                           "path" : "url",
                           "scope" : "E",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "63",
                        "locator" : "38:18-38:27",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "detailed",
                        "type" : "Literal"
                     } ]
                  } ]
               },
               "return" : {
                  "localId" : "70",
                  "locator" : "39:5-39:28",
                  "expression" : {
                     "localId" : "69",
                     "locator" : "39:12-39:28",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "67",
                        "locator" : "39:12-39:18",
                        "path" : "value",
                        "scope" : "E",
                        "type" : "Property"
                     },
                     "asTypeSpecifier" : {
                        "localId" : "68",
                        "locator" : "39:23-39:28",
                        "name" : "{http://hl7.org/fhir}Coding",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            }
         }, {
            "localId" : "93",
            "locator" : "41:1-46:5",
            "name" : "SDE Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "93",
                  "s" : [ {
                     "value" : [ "define ","\"SDE Sex\"",":\r\n  " ]
                  }, {
                     "r" : "92",
                     "s" : [ {
                        "value" : [ "case\r\n    " ]
                     }, {
                        "r" : "81",
                        "s" : [ {
                           "value" : [ "when " ]
                        }, {
                           "r" : "76",
                           "s" : [ {
                              "r" : "74",
                              "s" : [ {
                                 "r" : "73",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "74",
                                 "s" : [ {
                                    "value" : [ "gender" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "75",
                              "s" : [ {
                                 "value" : [ "'male'" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " then " ]
                        }, {
                           "r" : "80",
                           "s" : [ {
                              "value" : [ "Code"," { " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "code",": " ]
                              }, {
                                 "r" : "77",
                                 "s" : [ {
                                    "value" : [ "'M'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "system",": " ]
                              }, {
                                 "r" : "78",
                                 "s" : [ {
                                    "value" : [ "'http://hl7.org/fhir/v3/AdministrativeGender'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "display",": " ]
                              }, {
                                 "r" : "79",
                                 "s" : [ {
                                    "value" : [ "'Male'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " }" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n    " ]
                     }, {
                        "r" : "90",
                        "s" : [ {
                           "value" : [ "when " ]
                        }, {
                           "r" : "85",
                           "s" : [ {
                              "r" : "83",
                              "s" : [ {
                                 "r" : "82",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "83",
                                 "s" : [ {
                                    "value" : [ "gender" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "84",
                              "s" : [ {
                                 "value" : [ "'female'" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " then " ]
                        }, {
                           "r" : "89",
                           "s" : [ {
                              "value" : [ "Code"," { " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "code",": " ]
                              }, {
                                 "r" : "86",
                                 "s" : [ {
                                    "value" : [ "'F'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "system",": " ]
                              }, {
                                 "r" : "87",
                                 "s" : [ {
                                    "value" : [ "'http://hl7.org/fhir/v3/AdministrativeGender'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "display",": " ]
                              }, {
                                 "r" : "88",
                                 "s" : [ {
                                    "value" : [ "'Female'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " }" ]
                           } ]
                        } ]
                     }, {
                        "r" : "91",
                        "value" : [ "\r\n    else ","null","\r\n  end" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "92",
               "locator" : "42:3-46:5",
               "type" : "Case",
               "caseItem" : [ {
                  "localId" : "81",
                  "locator" : "43:5-43:128",
                  "when" : {
                     "localId" : "76",
                     "locator" : "43:10-43:32",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "74",
                           "locator" : "43:10-43:23",
                           "path" : "gender",
                           "type" : "Property",
                           "source" : {
                              "localId" : "73",
                              "locator" : "43:10-43:16",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        } ]
                     }, {
                        "localId" : "75",
                        "locator" : "43:27-43:32",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "male",
                        "type" : "Literal"
                     } ]
                  },
                  "then" : {
                     "localId" : "80",
                     "locator" : "43:39-43:128",
                     "classType" : "{urn:hl7-org:elm-types:r1}Code",
                     "type" : "Instance",
                     "element" : [ {
                        "name" : "code",
                        "value" : {
                           "localId" : "77",
                           "locator" : "43:52-43:54",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "M",
                           "type" : "Literal"
                        }
                     }, {
                        "name" : "system",
                        "value" : {
                           "localId" : "78",
                           "locator" : "43:65-43:109",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "http://hl7.org/fhir/v3/AdministrativeGender",
                           "type" : "Literal"
                        }
                     }, {
                        "name" : "display",
                        "value" : {
                           "localId" : "79",
                           "locator" : "43:121-43:126",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "Male",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "90",
                  "locator" : "44:5-44:132",
                  "when" : {
                     "localId" : "85",
                     "locator" : "44:10-44:34",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "83",
                           "locator" : "44:10-44:23",
                           "path" : "gender",
                           "type" : "Property",
                           "source" : {
                              "localId" : "82",
                              "locator" : "44:10-44:16",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        } ]
                     }, {
                        "localId" : "84",
                        "locator" : "44:27-44:34",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "female",
                        "type" : "Literal"
                     } ]
                  },
                  "then" : {
                     "localId" : "89",
                     "locator" : "44:41-44:132",
                     "classType" : "{urn:hl7-org:elm-types:r1}Code",
                     "type" : "Instance",
                     "element" : [ {
                        "name" : "code",
                        "value" : {
                           "localId" : "86",
                           "locator" : "44:54-44:56",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "F",
                           "type" : "Literal"
                        }
                     }, {
                        "name" : "system",
                        "value" : {
                           "localId" : "87",
                           "locator" : "44:67-44:111",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "http://hl7.org/fhir/v3/AdministrativeGender",
                           "type" : "Literal"
                        }
                     }, {
                        "name" : "display",
                        "value" : {
                           "localId" : "88",
                           "locator" : "44:123-44:130",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "Female",
                           "type" : "Literal"
                        }
                     } ]
                  }
               } ],
               "else" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "As",
                  "operand" : {
                     "localId" : "91",
                     "locator" : "45:10-45:13",
                     "type" : "Null"
                  }
               }
            }
         } ]
      }
   }
}" + } ] + }, + "request": { + "method": "PUT", + "url": "Library/library-SupplementalDataElements-2.0.0" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113762.1.4.1", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113762.1.4.1" + } ], + "version": "20150331", + "name": "ONCAdministrativeSex", + "title": "ONC Administrative Sex", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://hl7.org/fhir/v3/AdministrativeGender", + "version": "HL7V3.0_2017-07", + "concept": [ { + "code": "F", + "display": "Female" + }, { + "code": "M", + "display": "Male" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113762.1.4.1" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.526.3.1240", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.526.3.1240" + } ], + "version": "20170504", + "name": "AnnualWellnessVisit", + "title": "Annual Wellness Visit", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "https://www.cms.gov/Medicare/Coding/MedHCPCSGenInfo/index.html", + "version": "2018", + "concept": [ { + "code": "G0438", + "display": "Annual wellness visit; includes a personalized prevention plan of service (pps), initial visit" + }, { + "code": "G0439", + "display": "Annual wellness visit, includes a personalized prevention plan of service (pps), subsequent visit" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.526.3.1240" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113762.1.4.1108.15", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1108.15", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113762.1.4.1108.15" + } ], + "version": "20170504", + "name": "Hospicecareambulatory", + "title": "Hospice care ambulatory", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "385763009", + "display": "Hospice care (regime/therapy)" + }, { + "code": "385765002", + "display": "Hospice care management (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113762.1.4.1108.15" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.114222.4.11.3591", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.114222.4.11.3591" + } ], + "version": "20180718", + "name": "Payer", + "title": "Payer", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://www.phdsc.org/standards/pdfs/SourceofPaymentTypologyVersion6FINALSeptember2015.pdf", + "version": "8.0", + "concept": [ { + "code": "1", + "display": "MEDICARE" + }, { + "code": "11", + "display": "Medicare (Managed Care)" + }, { + "code": "111", + "display": "Medicare HMO" + }, { + "code": "112", + "display": "Medicare PPO" + }, { + "code": "113", + "display": "Medicare POS" + }, { + "code": "119", + "display": "Medicare Managed Care Other" + }, { + "code": "12", + "display": "Medicare (Non-managed Care)" + }, { + "code": "121", + "display": "Medicare FFS" + }, { + "code": "122", + "display": "Medicare Drug Benefit" + }, { + "code": "123", + "display": "Medicare Medical Savings Account (MSA)" + }, { + "code": "129", + "display": "Medicare Non-managed Care Other" + }, { + "code": "13", + "display": "Medicare Hospice" + }, { + "code": "14", + "display": "Dual Eligibility Medicare/Medicaid Organization" + }, { + "code": "19", + "display": "Medicare Other" + }, { + "code": "191", + "display": "Medicare Pharmacy Benefit Manager" + }, { + "code": "2", + "display": "MEDICAID" + }, { + "code": "21", + "display": "Medicaid (Managed Care)" + }, { + "code": "211", + "display": "Medicaid HMO" + }, { + "code": "212", + "display": "Medicaid PPO" + }, { + "code": "213", + "display": "Medicaid PCCM (Primary Care Case Management)" + }, { + "code": "219", + "display": "Medicaid Managed Care Other" + }, { + "code": "22", + "display": "Medicaid (Non-managed Care Plan)" + }, { + "code": "23", + "display": "Medicaid/SCHIP" + }, { + "code": "25", + "display": "Medicaid - Out of State" + }, { + "code": "26", + "display": "Medicaid -- Long Term Care" + }, { + "code": "29", + "display": "Medicaid Other" + }, { + "code": "291", + "display": "Medicaid Pharmacy Benefit Manager" + }, { + "code": "299", + "display": "Medicaid - Dental" + }, { + "code": "3", + "display": "OTHER GOVERNMENT (Federal/State/Local) (excluding Department of Corrections)" + }, { + "code": "31", + "display": "Department of Defense" + }, { + "code": "311", + "display": "TRICARE (CHAMPUS)" + }, { + "code": "3111", + "display": "TRICARE Prime--HMO" + }, { + "code": "3112", + "display": "TRICARE Extra--PPO" + }, { + "code": "3113", + "display": "TRICARE Standard - Fee For Service" + }, { + "code": "3114", + "display": "TRICARE For Life--Medicare Supplement" + }, { + "code": "3115", + "display": "TRICARE Reserve Select" + }, { + "code": "3116", + "display": "Uniformed Services Family Health Plan (USFHP) -- HMO" + }, { + "code": "3119", + "display": "Department of Defense - (other)" + }, { + "code": "312", + "display": "Military Treatment Facility" + }, { + "code": "3121", + "display": "Enrolled Prime--HMO" + }, { + "code": "3122", + "display": "Non-enrolled Space Available" + }, { + "code": "3123", + "display": "TRICARE For Life (TFL)" + }, { + "code": "313", + "display": "Dental --Stand Alone" + }, { + "code": "32", + "display": "Department of Veterans Affairs" + }, { + "code": "321", + "display": "Veteran care--Care provided to Veterans" + }, { + "code": "3211", + "display": "Direct Care--Care provided in VA facilities" + }, { + "code": "3212", + "display": "Indirect Care--Care provided outside VA facilities" + }, { + "code": "32121", + "display": "Fee Basis" + }, { + "code": "32122", + "display": "Foreign Fee/Foreign Medical Program (FMP)" + }, { + "code": "32123", + "display": "Contract Nursing Home/Community Nursing Home" + }, { + "code": "32124", + "display": "State Veterans Home" + }, { + "code": "32125", + "display": "Sharing Agreements" + }, { + "code": "32126", + "display": "Other Federal Agency" + }, { + "code": "32127", + "display": "Dental Care" + }, { + "code": "32128", + "display": "Vision Care" + }, { + "code": "322", + "display": "Non-veteran care" + }, { + "code": "3221", + "display": "Civilian Health and Medical Program for the VA (CHAMPVA)" + }, { + "code": "3222", + "display": "Spina Bifida Health Care Program (SB)" + }, { + "code": "3223", + "display": "Children of Women Vietnam Veterans (CWVV)" + }, { + "code": "3229", + "display": "Other non-veteran care" + }, { + "code": "33", + "display": "Indian Health Service or Tribe" + }, { + "code": "331", + "display": "Indian Health Service -- Regular" + }, { + "code": "332", + "display": "Indian Health Service -- Contract" + }, { + "code": "333", + "display": "Indian Health Service - Managed Care" + }, { + "code": "334", + "display": "Indian Tribe - Sponsored Coverage" + }, { + "code": "34", + "display": "HRSA Program" + }, { + "code": "341", + "display": "Title V (MCH Block Grant)" + }, { + "code": "342", + "display": "Migrant Health Program" + }, { + "code": "343", + "display": "Ryan White Act" + }, { + "code": "349", + "display": "Other" + }, { + "code": "35", + "display": "Black Lung" + }, { + "code": "36", + "display": "State Government" + }, { + "code": "361", + "display": "State SCHIP program (codes for individual states)" + }, { + "code": "362", + "display": "Specific state programs (list/ local code)" + }, { + "code": "369", + "display": "State, not otherwise specified (other state)" + }, { + "code": "37", + "display": "Local Government" + }, { + "code": "371", + "display": "Local - Managed care" + }, { + "code": "3711", + "display": "HMO" + }, { + "code": "3712", + "display": "PPO" + }, { + "code": "3713", + "display": "POS" + }, { + "code": "372", + "display": "FFS/Indemnity" + }, { + "code": "379", + "display": "Local, not otherwise specified (other local, county)" + }, { + "code": "38", + "display": "Other Government (Federal, State, Local not specified)" + }, { + "code": "381", + "display": "Federal, State, Local not specified managed care" + }, { + "code": "3811", + "display": "Federal, State, Local not specified - HMO" + }, { + "code": "3812", + "display": "Federal, State, Local not specified - PPO" + }, { + "code": "3813", + "display": "Federal, State, Local not specified - POS" + }, { + "code": "3819", + "display": "Federal, State, Local not specified - not specified managed care" + }, { + "code": "382", + "display": "Federal, State, Local not specified - FFS" + }, { + "code": "389", + "display": "Federal, State, Local not specified - Other" + }, { + "code": "39", + "display": "Other Federal" + }, { + "code": "391", + "display": "Federal Employee Health Plan - Use when known" + }, { + "code": "4", + "display": "DEPARTMENTS OF CORRECTIONS" + }, { + "code": "41", + "display": "Corrections Federal" + }, { + "code": "42", + "display": "Corrections State" + }, { + "code": "43", + "display": "Corrections Local" + }, { + "code": "44", + "display": "Corrections Unknown Level" + }, { + "code": "5", + "display": "PRIVATE HEALTH INSURANCE" + }, { + "code": "51", + "display": "Managed Care (Private)" + }, { + "code": "511", + "display": "Commercial Managed Care - HMO" + }, { + "code": "512", + "display": "Commercial Managed Care - PPO" + }, { + "code": "513", + "display": "Commercial Managed Care - POS" + }, { + "code": "514", + "display": "Exclusive Provider Organization" + }, { + "code": "515", + "display": "Gatekeeper PPO (GPPO)" + }, { + "code": "516", + "display": "Commercial Managed Care - Pharmacy Benefit Manager" + }, { + "code": "517", + "display": "Commercial Managed Care - Dental" + }, { + "code": "519", + "display": "Managed Care, Other (non HMO)" + }, { + "code": "52", + "display": "Private Health Insurance - Indemnity" + }, { + "code": "521", + "display": "Commercial Indemnity" + }, { + "code": "522", + "display": "Self-insured (ERISA) Administrative Services Only (ASO) plan" + }, { + "code": "523", + "display": "Medicare supplemental policy (as second payer)" + }, { + "code": "524", + "display": "Indemnity Insurance - Dental" + }, { + "code": "529", + "display": "Private health insurance--other commercial Indemnity" + }, { + "code": "53", + "display": "Managed Care (private) or private health insurance (indemnity), not otherwise specified" + }, { + "code": "54", + "display": "Organized Delivery System" + }, { + "code": "55", + "display": "Small Employer Purchasing Group" + }, { + "code": "56", + "display": "Specialized Stand Alone Plan" + }, { + "code": "561", + "display": "Dental" + }, { + "code": "562", + "display": "Vision" + }, { + "code": "59", + "display": "Other Private Insurance" + }, { + "code": "6", + "display": "BLUE CROSS/BLUE SHIELD" + }, { + "code": "61", + "display": "BC Managed Care" + }, { + "code": "611", + "display": "BC Managed Care -- HMO" + }, { + "code": "612", + "display": "BC Managed Care -- PPO" + }, { + "code": "613", + "display": "BC Managed Care -- POS" + }, { + "code": "614", + "display": "BC Managed Care - Dental" + }, { + "code": "619", + "display": "BC Managed Care -- Other" + }, { + "code": "62", + "display": "BC Insurance Indemnity" + }, { + "code": "621", + "display": "BC Indemnity" + }, { + "code": "622", + "display": "BC Self-insured (ERISA) Administrative Services Only (ASO)Plan" + }, { + "code": "623", + "display": "BC Medicare Supplemental Plan" + }, { + "code": "629", + "display": "BC Indemnity - Dental" + }, { + "code": "7", + "display": "MANAGED CARE, UNSPECIFIED (to be used only if one can't distinguish public from private)" + }, { + "code": "71", + "display": "HMO" + }, { + "code": "72", + "display": "PPO" + }, { + "code": "73", + "display": "POS" + }, { + "code": "79", + "display": "Other Managed Care" + }, { + "code": "8", + "display": "NO PAYMENT from an Organization/Agency/Program/Private Payer Listed" + }, { + "code": "81", + "display": "Self-pay (Includes applicants for insurance and Medicaid applicants)" + }, { + "code": "82", + "display": "No Charge" + }, { + "code": "821", + "display": "Charity" + }, { + "code": "822", + "display": "Professional Courtesy" + }, { + "code": "823", + "display": "Research/Clinical Trial" + }, { + "code": "83", + "display": "Refusal to Pay/Bad Debt" + }, { + "code": "84", + "display": "Hill Burton Free Care" + }, { + "code": "85", + "display": "Research/Donor" + }, { + "code": "89", + "display": "No Payment, Other" + }, { + "code": "9", + "display": "MISCELLANEOUS/OTHER" + }, { + "code": "91", + "display": "Foreign National" + }, { + "code": "92", + "display": "Other (Non-government)" + }, { + "code": "93", + "display": "Disability Insurance" + }, { + "code": "94", + "display": "Long-term Care Insurance" + }, { + "code": "95", + "display": "Worker's Compensation" + }, { + "code": "951", + "display": "Worker's Comp HMO" + }, { + "code": "953", + "display": "Worker's Comp Fee-for-Service" + }, { + "code": "954", + "display": "Worker's Comp Other Managed Care" + }, { + "code": "959", + "display": "Worker's Comp, Other unspecified" + }, { + "code": "96", + "display": "Auto Insurance (includes no fault)" + }, { + "code": "97", + "display": "Legal Liability / Liability Insurance" + }, { + "code": "98", + "display": "Other specified but not otherwise classifiable (includes Hospice - Unspecified plan)" + }, { + "code": "99", + "display": "No Typology Code available for payment source" + }, { + "code": "9999", + "display": "Unavailable / No Payer Specified / Blank" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.114222.4.11.3591" + } + }, { + "resource": { + "resourceType": "Library", + "id": "library-MATGlobalCommonFunctions-5.0.000", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "#cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/dbcg/connectathon/Library/MATGlobalCommonFunctions", + "version": "5.0.000", + "name": "MATGlobalCommonFunctions", + "status": "active", + "experimental": true, + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } ] + }, + "relatedArtifact": [ { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIRHelpers|4.0.1" + }, { + "type": "depends-on", + "resource": "http://loinc.org" + }, { + "type": "depends-on", + "resource": "http://snomed.info/sct/731000124108" + }, { + "type": "depends-on", + "resource": "http://hl7.org/fhir/v3/RoleCode" + }, { + "type": "depends-on", + "resource": "http://terminology.hl7.org/CodeSystem/diagnosis-role" + }, { + "type": "depends-on", + "resource": "http://terminology.hl7.org/CodeSystem/request-intent" + }, { + "type": "depends-on", + "resource": "http://terminology.hl7.org/CodeSystem/medicationrequest-category" + }, { + "type": "depends-on", + "resource": "http://terminology.hl7.org/CodeSystem/condition-clinical" + }, { + "type": "depends-on", + "resource": "http://terminology.hl7.org/CodeSystem/condition-verification" + }, { + "type": "depends-on", + "resource": "http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical" + }, { + "type": "depends-on", + "resource": "http://terminology.hl7.org/CodeSystem/allergyintolerance-verification" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.117.1.7.1.292" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1111.143" + } ], + "parameter": [ { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Patient" + }, { + "name": "Inpatient Encounter", + "use": "out", + "min": 0, + "max": "*", + "type": "Encounter" + } ], + "dataRequirement": [ { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.117.1.7.1.292" + } ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1111.143" + } ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.117.1.7.1.292" + } ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ] + }, { + "type": "Location", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Location" ] + }, { + "type": "Provenance", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Provenance" ], + "codeFilter": [ { + "path": "target" + } ] + }, { + "type": "Medication", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Medication" ] + } ], + "content": [ { + "contentType": "text/cql", + "data": "library MATGlobalCommonFunctions version '5.0.000'

using FHIR version '4.0.1'

include FHIRHelpers version '4.0.1' called FHIRHelpers

codesystem "LOINC": 'http://loinc.org'
codesystem "SNOMEDCT": 'http://snomed.info/sct/731000124108'
codesystem "RoleCode": 'http://hl7.org/fhir/v3/RoleCode'
codesystem "Diagnosis Role": 'http://terminology.hl7.org/CodeSystem/diagnosis-role'
codesystem "RequestIntent": 'http://terminology.hl7.org/CodeSystem/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-verification'
codesystem "AllergyIntoleranceClinicalStatusCodes": 'http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical'
codesystem "AllergyIntoleranceVerificationStatusCodes": 'http://terminology.hl7.org/CodeSystem/allergyintolerance-verification'

valueset "Encounter Inpatient": 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307'
valueset "Emergency Department Visit": 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.117.1.7.1.292'
valueset "Observation Services": 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1111.143'

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'

// 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 "Community": 'community' from "MedicationRequestCategory" display 'Community'
code "Discharge": 'discharge' from "MedicationRequestCategory" display 'Discharge'

parameter "Measurement Period" Interval<DateTime>
  default Interval[@2019-01-01T00:00:00.0, @2020-01-01T00:00:00.0)

context Patient

define "Inpatient Encounter":
	[Encounter: "Encounter Inpatient"] EncounterInpatient
		where EncounterInpatient.status = 'finished'
		    and "LengthInDays"(EncounterInpatient.period) <= 120
			and EncounterInpatient.period ends during "Measurement Period"

define function "ToDate"(Value DateTime):
	DateTime(year from Value, month from Value, day from Value, 0, 0, 0, 0, timezoneoffset from Value)

define function "CalendarAgeInDaysAt"(BirthDateTime DateTime, AsOf DateTime):
	days between ToDate(BirthDateTime)and ToDate(AsOf)

define function "CalendarAgeInDays"(BirthDateTime DateTime):
	CalendarAgeInDaysAt(BirthDateTime, Today())

define function "CalendarAgeInMonthsAt"(BirthDateTime DateTime, AsOf DateTime):
	months between ToDate(BirthDateTime)and ToDate(AsOf)

define function "CalendarAgeInMonths"(BirthDateTime DateTime):
	CalendarAgeInMonthsAt(BirthDateTime, Today())

define function "CalendarAgeInYearsAt"(BirthDateTime DateTime, AsOf DateTime):
	years between ToDate(BirthDateTime)and ToDate(AsOf)

define function "CalendarAgeInYears"(BirthDateTime DateTime):
	CalendarAgeInYearsAt(BirthDateTime, Today())

define function "LengthInDays"(Value Interval<DateTime>):
	difference in days between start of Value and end of Value

define function "ED Visit"(TheEncounter FHIR.Encounter):
    singleton from (
        [Encounter: "Emergency Department Visit"] EDVisit
            where EDVisit.status = 'finished'
                and EDVisit.period ends 1 hour or less on or before start of FHIRHelpers.ToInterval(TheEncounter.period)
    )

define function "Hospitalization"(TheEncounter FHIR.Encounter):
	( "ED Visit"(TheEncounter) ) X
    return
        if X is null then TheEncounter.period
        else Interval[start of FHIRHelpers.ToInterval(X.period), end of FHIRHelpers.ToInterval(TheEncounter.period)]

define function "Hospitalization Locations"(TheEncounter FHIR.Encounter):
	( "ED Visit"(TheEncounter) ) EDEncounter
    return
        if EDEncounter is null then TheEncounter.location
        else flatten { EDEncounter.location, TheEncounter.location }

define function "Hospitalization Length of Stay"(TheEncounter FHIR.Encounter):
	LengthInDays("Hospitalization"(TheEncounter))

define function "Hospital Admission Time"(TheEncounter FHIR.Encounter):
	start of "Hospitalization"(TheEncounter)

define function "Hospital Discharge Time"(TheEncounter FHIR.Encounter):
	end of FHIRHelpers.ToInterval(TheEncounter.period)

define function "Hospital Arrival Time"(TheEncounter FHIR.Encounter):
	start of FHIRHelpers.ToInterval(First(
	    ( "Hospitalization Locations"(TheEncounter) ) HospitalLocation
			sort by start of FHIRHelpers.ToInterval(period)
	).period)

define function "HospitalizationWithObservation"(TheEncounter FHIR.Encounter):
	TheEncounter Visit
		let ObsVisit: Last([Encounter: "Observation Services"] LastObs
				where LastObs.period ends 1 hour or less on or before start of Visit.period
				sort by end of period
			),
			VisitStart: Coalesce(start of ObsVisit.period, start of Visit.period),
			EDVisit: Last([Encounter: "Emergency Department Visit"] LastED
				where LastED.period ends 1 hour or less on or before VisitStart
				sort by end of period
			)
		return Interval[Coalesce(start of EDVisit.period, VisitStart), end of Visit.period]

define function "HospitalizationWithObservationLengthofStay"(Encounter FHIR.Encounter):
	"LengthInDays"("HospitalizationWithObservation"(Encounter))

// TODO - fix these (must fetch Location resources and compare id to reference)
/*define function "Hospital Departure Time"(TheEncounter FHIR.Encounter):
	end of FHIRHelpers.ToInterval(Last(
	    ( "Hospitalization Locations"(TheEncounter) ) HospitalLocation
			sort by start of FHIRHelpers.ToInterval(period)
	).period)

define function "Emergency Department Arrival Time"(TheEncounter FHIR.Encounter):
	start of FHIRHelpers.ToInterval((
	    singleton from (
	        ( "Hospitalization Locations"(TheEncounter) ) HospitalLocation
				where HospitalLocation.type ~ "ER"
		)
	).period)

define function "First Inpatient Intensive Care Unit"(TheEncounter FHIR.Encounter):
	First(
	    ( TheEncounter.location ) HospitalLocation
			where HospitalLocation.type ~ "ICU"
				and HospitalLocation.period during TheEncounter.period
			sort by start of FHIRHelpers.ToInterval(period)
	)*/

/*
*
*    CQFMeasures Common Logic
*
*/

define function "Normalize Interval"(choice Choice<FHIR.dateTime, FHIR.Period, FHIR.Timing, FHIR.instant, FHIR.string, FHIR.Age, FHIR.Range>):
  case
	  when choice is FHIR.dateTime then
    	Interval[FHIRHelpers.ToDateTime(choice as FHIR.dateTime), FHIRHelpers.ToDateTime(choice as FHIR.dateTime)]
		when choice is FHIR.Period then
  		FHIRHelpers.ToInterval(choice as FHIR.Period)
		when choice is FHIR.instant then
			Interval[FHIRHelpers.ToDateTime(choice as FHIR.instant), FHIRHelpers.ToDateTime(choice as FHIR.instant)]
		when choice is FHIR.Age then
		  Interval[FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity(choice as FHIR.Age),
			  FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity(choice as FHIR.Age) + 1 year)
		when choice is FHIR.Range then
		  Interval[FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity((choice as FHIR.Range).low),
			  FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity((choice as FHIR.Range).high) + 1 year)
		when choice is FHIR.Timing then
		  Message(null as Interval<DateTime>, true, '1', 'Error', 'Cannot compute a single interval from a Timing type')
    when choice is FHIR.string then
      Message(null as Interval<DateTime>, true, '1', 'Error', 'Cannot compute an interval from a String value')
		else
			null as Interval<DateTime>
	end

define function "Normalize Abatement"(condition Condition):
	if condition.abatement is FHIR.dateTime then
	  Interval[FHIRHelpers.ToDateTime(condition.abatement as FHIR.dateTime), FHIRHelpers.ToDateTime(condition.abatement as FHIR.dateTime)]
	else if condition.abatement is FHIR.Period then
	  FHIRHelpers.ToInterval(condition.abatement as FHIR.Period)
	else if condition.abatement is FHIR.string then
    Message(null as Interval<DateTime>, true, '1', 'Error', 'Cannot compute an interval from a String value')
	else if condition.abatement is FHIR.Age then
		Interval[FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity(condition.abatement as FHIR.Age),
			FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity(condition.abatement as FHIR.Age) + 1 year)
	else if condition.abatement is FHIR.Range then
	  Interval[FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity((condition.abatement as FHIR.Range).low),
		  FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity((condition.abatement as FHIR.Range).high) + 1 year)
	else if condition.abatement is FHIR.boolean then
	  Interval[end of "Normalize Interval"(condition.onset), condition.recordedDate)
	else null

define function "Prevalence Period"(condition Condition):
  Interval[start of "Normalize Interval"(condition.onset), end of "Normalize Abatement"(condition))

define function "GetId"(uri String):
	Last(Split(uri, '/'))


define function "EncounterDiagnosis"(Encounter Encounter):
  Encounter.diagnosis D
    return singleton from ([Condition] C where C.id = "GetId"(D.condition.reference))

// Returns the condition that is specified as the principal diagnosis for the encounter
// TODO: BTR 2019-07-30: Shouldn't need the FHIRHelpers reference here, investigate
define function "PrincipalDiagnosis"(Encounter Encounter):
	(singleton from (Encounter.diagnosis D where FHIRHelpers.ToInteger(D.rank) = 1)) PD
		return singleton from ([Condition] C where C.id = "GetId"(PD.condition.reference))

// Returns the location for the given location reference
define function GetLocation(reference Reference):
  singleton from (
    [Location] L where L.id = GetId(reference.reference)
  )

/*
NOTE: Extensions are not the preferred approach, but are used as a way to access
content that is defined by extensions but not yet surfaced in the
CQL model info.
*/
define function "GetExtensions"(domainResource DomainResource, url String):
  domainResource.extension E
	  where E.url = ('http://hl7.org/fhir/us/qicore/StructureDefinition/' + url)
		return E

define function "GetExtension"(domainResource DomainResource, url String):
  singleton from "GetExtensions"(domainResource, url)

/*
NOTE: Extensions are not the preferred approach, but are used as a way to access
content that is defined by extensions but not yet surfaced in the
CQL model info.
*/
define function "GetExtensions"(element Element, url String):
  element.extension E
	  where E.url = (url)
		return E

define function "GetExtension"(element Element, url String):
  singleton from "GetExtensions"(element, url)

/*
NOTE: Extensions are not the preferred approach, but are used as a way to access
content that is defined by extensions but not yet surfaced in the
CQL model info.
*/
define function "GetBaseExtensions"(domainResource DomainResource, url String):
  domainResource.extension E
	  where E.url = ('http://hl7.org/fhir/StructureDefinition/' + url)
		return E

define function "GetBaseExtension"(domainResource DomainResource, url String):
  singleton from "GetBaseExtensions"(domainResource, url)

/*
NOTE: Provenance is not the preferred approach, this is provided only as an illustration
for what using Provenance could look like, and is not a tested pattern
*/
define function "GetProvenance"(resource Resource):
  singleton from ([Provenance: target in resource.id])

define function "GetMedicationCode"(request MedicationRequest):
  if request.medication is CodeableConcept then
	  request.medication as CodeableConcept
	else
	  (singleton from ([Medication] M where M.id = GetId((request.medication as Reference).reference))).code
" + }, { + "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 translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <annotation librarySystem="http://fhir.org/guides/dbcg/connectathon" libraryId="MATGlobalCommonFunctions" libraryVersion="5.0.000" startLine="277" startChar="19" endLine="277" endChar="53" message="Could not resolve membership operator for terminology target of the retrieve." errorType="semantic" errorSeverity="warning" xsi:type="a:CqlToElmError"/>
   <identifier id="MATGlobalCommonFunctions" system="http://fhir.org/guides/dbcg/connectathon" version="5.0.000"/>
   <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:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1"/>
   </usings>
   <includes>
      <def localId="2" locator="5:1-5:54" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/dbcg/connectathon/FHIRHelpers" version="4.0.1"/>
   </includes>
   <parameters>
      <def localId="71" locator="57:1-58:66" name="Measurement Period" accessLevel="Public">
         <default localId="68" locator="58:11-58:66" lowClosed="true" highClosed="false" xsi:type="Interval">
            <low localId="66" locator="58:20-58:41" xsi:type="DateTime">
               <year valueType="t:Integer" value="2019" xsi:type="Literal"/>
               <month valueType="t:Integer" value="1" xsi:type="Literal"/>
               <day valueType="t:Integer" value="1" xsi:type="Literal"/>
               <hour valueType="t:Integer" value="0" xsi:type="Literal"/>
               <minute valueType="t:Integer" value="0" xsi:type="Literal"/>
               <second valueType="t:Integer" value="0" xsi:type="Literal"/>
               <millisecond valueType="t:Integer" value="0" xsi:type="Literal"/>
            </low>
            <high localId="67" locator="58:44-58:65" xsi:type="DateTime">
               <year valueType="t:Integer" value="2020" xsi:type="Literal"/>
               <month valueType="t:Integer" value="1" xsi:type="Literal"/>
               <day valueType="t:Integer" value="1" xsi:type="Literal"/>
               <hour valueType="t:Integer" value="0" xsi:type="Literal"/>
               <minute valueType="t:Integer" value="0" xsi:type="Literal"/>
               <second valueType="t:Integer" value="0" xsi:type="Literal"/>
               <millisecond valueType="t:Integer" value="0" xsi:type="Literal"/>
            </high>
         </default>
         <parameterTypeSpecifier localId="70" locator="57:32-57:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="69" locator="57:41-57:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <codeSystems>
      <def localId="3" locator="7:1-7:38" name="LOINC" id="http://loinc.org" accessLevel="Public"/>
      <def localId="4" locator="8:1-8:60" name="SNOMEDCT" id="http://snomed.info/sct/731000124108" accessLevel="Public"/>
      <def localId="5" locator="9:1-9:56" name="RoleCode" id="http://hl7.org/fhir/v3/RoleCode" accessLevel="Public"/>
      <def localId="6" locator="10:1-10:83" name="Diagnosis Role" id="http://terminology.hl7.org/CodeSystem/diagnosis-role" accessLevel="Public"/>
      <def localId="7" locator="11:1-11:82" name="RequestIntent" id="http://terminology.hl7.org/CodeSystem/request-intent" accessLevel="Public"/>
      <def localId="8" locator="12:1-12:106" name="MedicationRequestCategory" id="http://terminology.hl7.org/CodeSystem/medicationrequest-category" accessLevel="Public"/>
      <def localId="9" locator="13:1-13:101" name="ConditionClinicalStatusCodes" id="http://terminology.hl7.org/CodeSystem/condition-clinical" accessLevel="Public"/>
      <def localId="10" locator="14:1-14:109" name="ConditionVerificationStatusCodes" id="http://terminology.hl7.org/CodeSystem/condition-verification" accessLevel="Public"/>
      <def localId="11" locator="15:1-15:119" name="AllergyIntoleranceClinicalStatusCodes" id="http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical" accessLevel="Public"/>
      <def localId="12" locator="16:1-16:127" name="AllergyIntoleranceVerificationStatusCodes" id="http://terminology.hl7.org/CodeSystem/allergyintolerance-verification" accessLevel="Public"/>
   </codeSystems>
   <valueSets>
      <def localId="13" locator="18:1-18:100" name="Encounter Inpatient" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" accessLevel="Public"/>
      <def localId="14" locator="19:1-19:111" name="Emergency Department Visit" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.117.1.7.1.292" accessLevel="Public"/>
      <def localId="15" locator="20:1-20:102" name="Observation Services" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1111.143" accessLevel="Public"/>
   </valueSets>
   <codes>
      <def localId="17" locator="22:1-22:61" name="Birthdate" id="21112-8" display="Birth date" accessLevel="Public">
         <codeSystem localId="16" locator="22:34-22:40" name="LOINC"/>
      </def>
      <def localId="19" locator="23:1-23:55" name="Dead" id="419099009" display="Dead" accessLevel="Public">
         <codeSystem localId="18" locator="23:31-23:40" name="SNOMEDCT"/>
      </def>
      <def localId="21" locator="24:1-24:56" name="ER" id="ER" display="Emergency room" accessLevel="Public">
         <codeSystem localId="20" locator="24:22-24:31" name="RoleCode"/>
      </def>
      <def localId="23" locator="25:1-25:63" name="ICU" id="ICU" display="Intensive care unit" accessLevel="Public">
         <codeSystem localId="22" locator="25:24-25:33" name="RoleCode"/>
      </def>
      <def localId="25" locator="26:1-26:65" name="Billing" id="billing" display="Billing" accessLevel="Public">
         <codeSystem localId="24" locator="26:32-26:47" name="Diagnosis Role"/>
      </def>
      <def localId="27" locator="29:1-29:59" name="active" id="active" accessLevel="Public">
         <codeSystem localId="26" locator="29:30-29:59" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="29" locator="30:1-30:67" name="recurrence" id="recurrence" accessLevel="Public">
         <codeSystem localId="28" locator="30:38-30:67" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="31" locator="31:1-31:61" name="relapse" id="relapse" accessLevel="Public">
         <codeSystem localId="30" locator="31:32-31:61" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="33" locator="32:1-32:63" name="inactive" id="inactive" accessLevel="Public">
         <codeSystem localId="32" locator="32:34-32:63" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="35" locator="33:1-33:65" name="remission" id="remission" accessLevel="Public">
         <codeSystem localId="34" locator="33:36-33:65" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="37" locator="34:1-34:63" name="resolved" id="resolved" accessLevel="Public">
         <codeSystem localId="36" locator="34:34-34:63" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="39" locator="37:1-37:71" name="unconfirmed" id="unconfirmed" accessLevel="Public">
         <codeSystem localId="38" locator="37:40-37:71" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="41" locator="38:1-38:71" name="provisional" id="provisional" accessLevel="Public">
         <codeSystem localId="40" locator="38:40-38:71" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="43" locator="39:1-39:73" name="differential" id="differential" accessLevel="Public">
         <codeSystem localId="42" locator="39:42-39:73" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="45" locator="40:1-40:67" name="confirmed" id="confirmed" accessLevel="Public">
         <codeSystem localId="44" locator="40:36-40:67" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="47" locator="41:1-41:63" name="refuted" id="refuted" accessLevel="Public">
         <codeSystem localId="46" locator="41:32-41:63" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="49" locator="42:1-42:81" name="entered-in-error" id="entered-in-error" accessLevel="Public">
         <codeSystem localId="48" locator="42:50-42:81" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="51" locator="44:1-44:76" name="allergy-active" id="active" accessLevel="Public">
         <codeSystem localId="50" locator="44:38-44:76" name="AllergyIntoleranceClinicalStatusCodes"/>
      </def>
      <def localId="53" locator="45:1-45:80" name="allergy-inactive" id="inactive" accessLevel="Public">
         <codeSystem localId="52" locator="45:42-45:80" name="AllergyIntoleranceClinicalStatusCodes"/>
      </def>
      <def localId="55" locator="46:1-46:80" name="allergy-resolved" id="resolved" accessLevel="Public">
         <codeSystem localId="54" locator="46:42-46:80" name="AllergyIntoleranceClinicalStatusCodes"/>
      </def>
      <def localId="57" locator="49:1-49:88" name="allergy-unconfirmed" id="unconfirmed" accessLevel="Public">
         <codeSystem localId="56" locator="49:48-49:88" name="AllergyIntoleranceVerificationStatusCodes"/>
      </def>
      <def localId="59" locator="50:1-50:84" name="allergy-confirmed" id="confirmed" accessLevel="Public">
         <codeSystem localId="58" locator="50:44-50:84" name="AllergyIntoleranceVerificationStatusCodes"/>
      </def>
      <def localId="61" locator="51:1-51:80" name="allergy-refuted" id="refuted" accessLevel="Public">
         <codeSystem localId="60" locator="51:40-51:80" name="AllergyIntoleranceVerificationStatusCodes"/>
      </def>
      <def localId="63" locator="54:1-54:82" name="Community" id="community" display="Community" accessLevel="Public">
         <codeSystem localId="62" locator="54:36-54:62" name="MedicationRequestCategory"/>
      </def>
      <def localId="65" locator="55:1-55:82" name="Discharge" id="discharge" display="Discharge" accessLevel="Public">
         <codeSystem localId="64" locator="55:36-55:62" name="MedicationRequestCategory"/>
      </def>
   </codes>
   <statements>
      <def locator="60:1-60:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="60:1-60:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/StructureDefinition/Patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="87" locator="89:1-90:59" name="LengthInDays" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="87">
               <a:s>define function &quot;LengthInDays&quot;(Value </a:s>
               <a:s r="81">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="80">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="86">
                  <a:s r="86">
                     <a:s>difference in days between </a:s>
                     <a:s r="83">
                        <a:s>start of </a:s>
                        <a:s r="82">
                           <a:s>Value</a:s>
                        </a:s>
                     </a:s>
                     <a:s> and </a:s>
                     <a:s r="85">
                        <a:s>end of </a:s>
                        <a:s r="84">
                           <a:s>Value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="86" locator="90:2-90:59" precision="Day" xsi:type="DifferenceBetween">
            <operand localId="83" locator="90:29-90:42" xsi:type="Start">
               <operand localId="82" locator="90:38-90:42" name="Value" xsi:type="OperandRef"/>
            </operand>
            <operand localId="85" locator="90:48-90:59" xsi:type="End">
               <operand localId="84" locator="90:55-90:59" name="Value" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="Value">
            <operandTypeSpecifier localId="81" locator="89:38-89:55" xsi:type="IntervalTypeSpecifier">
               <pointType localId="80" locator="89:47-89:54" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="98" locator="62:1-66:65" name="Inpatient Encounter" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="98">
               <a:s>define &quot;Inpatient Encounter&quot;:&#xd;
	</a:s>
               <a:s r="97">
                  <a:s>
                     <a:s r="73">
                        <a:s r="72">
                           <a:s r="72">
                              <a:s>[Encounter: </a:s>
                              <a:s>
                                 <a:s>&quot;Encounter Inpatient&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> EncounterInpatient</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="96">
                     <a:s>where </a:s>
                     <a:s r="96">
                        <a:s r="91">
                           <a:s r="77">
                              <a:s r="75">
                                 <a:s r="74">
                                    <a:s>EncounterInpatient</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="75">
                                    <a:s>status</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> = </a:s>
                              <a:s r="76">
                                 <a:s>'finished'</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
		    and </a:s>
                           <a:s r="90">
                              <a:s r="88">
                                 <a:s>&quot;LengthInDays&quot;(</a:s>
                                 <a:s r="79">
                                    <a:s r="78">
                                       <a:s>EncounterInpatient</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="79">
                                       <a:s>period</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s r="89"> &lt;= 120</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
			and </a:s>
                        <a:s r="95">
                           <a:s r="93">
                              <a:s r="92">
                                 <a:s>EncounterInpatient</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="93">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="95"> ends during </a:s>
                           <a:s r="94">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="97" locator="63:2-66:65" xsi:type="Query">
            <source localId="73" locator="63:2-63:54" alias="EncounterInpatient">
               <expression localId="72" locator="63:2-63:35" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                  <codes locator="63:14-63:34" name="Encounter Inpatient" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="96" locator="64:3-66:65" xsi:type="And">
               <operand localId="91" locator="64:9-65:58" xsi:type="And">
                  <operand localId="77" locator="64:9-64:46" xsi:type="Equal">
                     <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="75" locator="64:9-64:33" path="status" scope="EncounterInpatient" xsi:type="Property"/>
                     </operand>
                     <operand localId="76" locator="64:37-64:46" valueType="t:String" value="finished" xsi:type="Literal"/>
                  </operand>
                  <operand localId="90" locator="65:11-65:58" xsi:type="LessOrEqual">
                     <operand localId="88" locator="65:11-65:51" name="LengthInDays" xsi:type="FunctionRef">
                        <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="79" locator="65:26-65:50" path="period" scope="EncounterInpatient" xsi:type="Property"/>
                        </operand>
                     </operand>
                     <operand localId="89" locator="65:56-65:58" valueType="t:Integer" value="120" xsi:type="Literal"/>
                  </operand>
               </operand>
               <operand localId="95" locator="66:8-66:65" xsi:type="In">
                  <operand locator="66:34-66:37" xsi:type="End">
                     <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="93" locator="66:8-66:32" path="period" scope="EncounterInpatient" xsi:type="Property"/>
                     </operand>
                  </operand>
                  <operand localId="94" locator="66:46-66:65" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="113" locator="68:1-69:99" name="ToDate" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="113">
               <a:s>define function &quot;ToDate&quot;(Value </a:s>
               <a:s r="99">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="112">
                  <a:s r="112">
                     <a:s>DateTime(</a:s>
                     <a:s r="101">
                        <a:s>year from </a:s>
                        <a:s r="100">
                           <a:s>Value</a:s>
                        </a:s>
                     </a:s>
                     <a:s>, </a:s>
                     <a:s r="103">
                        <a:s>month from </a:s>
                        <a:s r="102">
                           <a:s>Value</a:s>
                        </a:s>
                     </a:s>
                     <a:s>, </a:s>
                     <a:s r="105">
                        <a:s>day from </a:s>
                        <a:s r="104">
                           <a:s>Value</a:s>
                        </a:s>
                     </a:s>
                     <a:s r="106">, 0, 0, 0, 0, </a:s>
                     <a:s r="111">
                        <a:s>timezoneoffset from </a:s>
                        <a:s r="110">
                           <a:s>Value</a:s>
                        </a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="112" locator="69:2-69:99" xsi:type="DateTime">
            <year localId="101" locator="69:11-69:25" precision="Year" xsi:type="DateTimeComponentFrom">
               <operand localId="100" locator="69:21-69:25" name="Value" xsi:type="OperandRef"/>
            </year>
            <month localId="103" locator="69:28-69:43" precision="Month" xsi:type="DateTimeComponentFrom">
               <operand localId="102" locator="69:39-69:43" name="Value" xsi:type="OperandRef"/>
            </month>
            <day localId="105" locator="69:46-69:59" precision="Day" xsi:type="DateTimeComponentFrom">
               <operand localId="104" locator="69:55-69:59" name="Value" xsi:type="OperandRef"/>
            </day>
            <hour localId="106" locator="69:62" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <minute localId="107" locator="69:65" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <second localId="108" locator="69:68" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <millisecond localId="109" locator="69:71" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <timezoneOffset localId="111" locator="69:74-69:98" xsi:type="TimezoneOffsetFrom">
               <operand localId="110" locator="69:94-69:98" name="Value" xsi:type="OperandRef"/>
            </timezoneOffset>
         </expression>
         <operand name="Value">
            <operandTypeSpecifier localId="99" locator="68:32-68:39" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="121" locator="71:1-72:51" name="CalendarAgeInDaysAt" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="121">
               <a:s>define function &quot;CalendarAgeInDaysAt&quot;(BirthDateTime </a:s>
               <a:s r="114">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>, AsOf </a:s>
               <a:s r="115">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="120">
                  <a:s r="120">
                     <a:s>days between </a:s>
                     <a:s r="117">
                        <a:s>ToDate(</a:s>
                        <a:s r="116">
                           <a:s>BirthDateTime</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>and </a:s>
                     <a:s r="119">
                        <a:s>ToDate(</a:s>
                        <a:s r="118">
                           <a:s>AsOf</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="120" locator="72:2-72:51" precision="Day" xsi:type="DurationBetween">
            <operand localId="117" locator="72:15-72:35" name="ToDate" xsi:type="FunctionRef">
               <operand localId="116" locator="72:22-72:34" name="BirthDateTime" xsi:type="OperandRef"/>
            </operand>
            <operand localId="119" locator="72:40-72:51" name="ToDate" xsi:type="FunctionRef">
               <operand localId="118" locator="72:47-72:50" name="AsOf" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="BirthDateTime">
            <operandTypeSpecifier localId="114" locator="71:53-71:60" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="AsOf">
            <operandTypeSpecifier localId="115" locator="71:68-71:75" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="126" locator="74:1-75:44" name="CalendarAgeInDays" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="126">
               <a:s>define function &quot;CalendarAgeInDays&quot;(BirthDateTime </a:s>
               <a:s r="122">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="125">
                  <a:s r="125">
                     <a:s>CalendarAgeInDaysAt(</a:s>
                     <a:s r="123">
                        <a:s>BirthDateTime</a:s>
                     </a:s>
                     <a:s>, </a:s>
                     <a:s r="124">
                        <a:s>Today()</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="125" locator="75:2-75:44" name="CalendarAgeInDaysAt" xsi:type="FunctionRef">
            <operand localId="123" locator="75:22-75:34" name="BirthDateTime" xsi:type="OperandRef"/>
            <operand xsi:type="ToDateTime">
               <operand localId="124" locator="75:37-75:43" xsi:type="Today"/>
            </operand>
         </expression>
         <operand name="BirthDateTime">
            <operandTypeSpecifier localId="122" locator="74:51-74:58" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="134" locator="77:1-78:53" name="CalendarAgeInMonthsAt" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="134">
               <a:s>define function &quot;CalendarAgeInMonthsAt&quot;(BirthDateTime </a:s>
               <a:s r="127">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>, AsOf </a:s>
               <a:s r="128">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="133">
                  <a:s r="133">
                     <a:s>months between </a:s>
                     <a:s r="130">
                        <a:s>ToDate(</a:s>
                        <a:s r="129">
                           <a:s>BirthDateTime</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>and </a:s>
                     <a:s r="132">
                        <a:s>ToDate(</a:s>
                        <a:s r="131">
                           <a:s>AsOf</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="133" locator="78:2-78:53" precision="Month" xsi:type="DurationBetween">
            <operand localId="130" locator="78:17-78:37" name="ToDate" xsi:type="FunctionRef">
               <operand localId="129" locator="78:24-78:36" name="BirthDateTime" xsi:type="OperandRef"/>
            </operand>
            <operand localId="132" locator="78:42-78:53" name="ToDate" xsi:type="FunctionRef">
               <operand localId="131" locator="78:49-78:52" name="AsOf" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="BirthDateTime">
            <operandTypeSpecifier localId="127" locator="77:55-77:62" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="AsOf">
            <operandTypeSpecifier localId="128" locator="77:70-77:77" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="139" locator="80:1-81:46" name="CalendarAgeInMonths" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="139">
               <a:s>define function &quot;CalendarAgeInMonths&quot;(BirthDateTime </a:s>
               <a:s r="135">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="138">
                  <a:s r="138">
                     <a:s>CalendarAgeInMonthsAt(</a:s>
                     <a:s r="136">
                        <a:s>BirthDateTime</a:s>
                     </a:s>
                     <a:s>, </a:s>
                     <a:s r="137">
                        <a:s>Today()</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="138" locator="81:2-81:46" name="CalendarAgeInMonthsAt" xsi:type="FunctionRef">
            <operand localId="136" locator="81:24-81:36" name="BirthDateTime" xsi:type="OperandRef"/>
            <operand xsi:type="ToDateTime">
               <operand localId="137" locator="81:39-81:45" xsi:type="Today"/>
            </operand>
         </expression>
         <operand name="BirthDateTime">
            <operandTypeSpecifier localId="135" locator="80:53-80:60" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="147" locator="83:1-84:52" name="CalendarAgeInYearsAt" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="147">
               <a:s>define function &quot;CalendarAgeInYearsAt&quot;(BirthDateTime </a:s>
               <a:s r="140">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>, AsOf </a:s>
               <a:s r="141">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="146">
                  <a:s r="146">
                     <a:s>years between </a:s>
                     <a:s r="143">
                        <a:s>ToDate(</a:s>
                        <a:s r="142">
                           <a:s>BirthDateTime</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>and </a:s>
                     <a:s r="145">
                        <a:s>ToDate(</a:s>
                        <a:s r="144">
                           <a:s>AsOf</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="146" locator="84:2-84:52" precision="Year" xsi:type="DurationBetween">
            <operand localId="143" locator="84:16-84:36" name="ToDate" xsi:type="FunctionRef">
               <operand localId="142" locator="84:23-84:35" name="BirthDateTime" xsi:type="OperandRef"/>
            </operand>
            <operand localId="145" locator="84:41-84:52" name="ToDate" xsi:type="FunctionRef">
               <operand localId="144" locator="84:48-84:51" name="AsOf" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="BirthDateTime">
            <operandTypeSpecifier localId="140" locator="83:54-83:61" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="AsOf">
            <operandTypeSpecifier localId="141" locator="83:69-83:76" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="152" locator="86:1-87:45" name="CalendarAgeInYears" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="152">
               <a:s>define function &quot;CalendarAgeInYears&quot;(BirthDateTime </a:s>
               <a:s r="148">
                  <a:s>DateTime</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="151">
                  <a:s r="151">
                     <a:s>CalendarAgeInYearsAt(</a:s>
                     <a:s r="149">
                        <a:s>BirthDateTime</a:s>
                     </a:s>
                     <a:s>, </a:s>
                     <a:s r="150">
                        <a:s>Today()</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="151" locator="87:2-87:45" name="CalendarAgeInYearsAt" xsi:type="FunctionRef">
            <operand localId="149" locator="87:23-87:35" name="BirthDateTime" xsi:type="OperandRef"/>
            <operand xsi:type="ToDateTime">
               <operand localId="150" locator="87:38-87:44" xsi:type="Today"/>
            </operand>
         </expression>
         <operand name="BirthDateTime">
            <operandTypeSpecifier localId="148" locator="86:52-86:59" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="175" locator="92:1-97:5" name="ED Visit" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="175">
               <a:s>define function &quot;ED Visit&quot;(TheEncounter </a:s>
               <a:s r="156">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
    </a:s>
               <a:s r="174">
                  <a:s r="174">
                     <a:s>singleton from </a:s>
                     <a:s r="173">
                        <a:s>(&#xd;
        </a:s>
                        <a:s r="173">
                           <a:s>
                              <a:s r="158">
                                 <a:s r="157">
                                    <a:s r="157">
                                       <a:s>[Encounter: </a:s>
                                       <a:s>
                                          <a:s>&quot;Emergency Department Visit&quot;</a:s>
                                       </a:s>
                                       <a:s>]</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> EDVisit</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
            </a:s>
                           <a:s r="172">
                              <a:s>where </a:s>
                              <a:s r="172">
                                 <a:s r="162">
                                    <a:s r="160">
                                       <a:s r="159">
                                          <a:s>EDVisit</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="160">
                                          <a:s>status</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> = </a:s>
                                    <a:s r="161">
                                       <a:s>'finished'</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
                and </a:s>
                                 <a:s r="171">
                                    <a:s r="164">
                                       <a:s r="163">
                                          <a:s>EDVisit</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="164">
                                          <a:s>period</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> </a:s>
                                    <a:s r="171">
                                       <a:s>ends </a:s>
                                       <a:s r="170">
                                          <a:s>1 hour</a:s>
                                       </a:s>
                                       <a:s> or less on or before</a:s>
                                    </a:s>
                                    <a:s> </a:s>
                                    <a:s r="169">
                                       <a:s>start of </a:s>
                                       <a:s r="168">
                                          <a:s r="165">
                                             <a:s>FHIRHelpers</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="168">
                                             <a:s>ToInterval(</a:s>
                                             <a:s r="167">
                                                <a:s r="166">
                                                   <a:s>TheEncounter</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="167">
                                                   <a:s>period</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>&#xd;
    )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="174" locator="93:5-97:5" xsi:type="SingletonFrom">
            <operand localId="173" locator="93:20-97:5" xsi:type="Query">
               <source localId="158" locator="94:9-94:57" alias="EDVisit">
                  <expression localId="157" locator="94:9-94:49" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                     <codes locator="94:21-94:48" name="Emergency Department Visit" xsi:type="ValueSetRef"/>
                  </expression>
               </source>
               <where localId="172" locator="95:13-96:120" xsi:type="And">
                  <operand localId="162" locator="95:19-95:45" xsi:type="Equal">
                     <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="160" locator="95:19-95:32" path="status" scope="EDVisit" xsi:type="Property"/>
                     </operand>
                     <operand localId="161" locator="95:36-95:45" valueType="t:String" value="finished" xsi:type="Literal"/>
                  </operand>
                  <operand localId="171" locator="96:21-96:120" xsi:type="And">
                     <operand locator="96:41-96:54" xsi:type="In">
                        <operand locator="96:36-96:39" xsi:type="End">
                           <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="164" locator="96:21-96:34" path="period" scope="EDVisit" xsi:type="Property"/>
                           </operand>
                        </operand>
                        <operand locator="96:41-96:54" lowClosed="true" highClosed="true" xsi:type="Interval">
                           <low locator="96:69-96:120" xsi:type="Subtract">
                              <operand localId="169" locator="96:69-96:120" xsi:type="Start">
                                 <operand localId="168" locator="96:78-96:120" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="167" locator="96:101-96:119" path="period" xsi:type="Property">
                                       <source localId="166" locator="96:101-96:112" name="TheEncounter" xsi:type="OperandRef"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="170" locator="96:41-96:46" value="1" unit="hour" xsi:type="Quantity"/>
                           </low>
                           <high localId="169" locator="96:69-96:120" xsi:type="Start">
                              <operand localId="168" locator="96:78-96:120" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="167" locator="96:101-96:119" path="period" xsi:type="Property">
                                    <source localId="166" locator="96:101-96:112" name="TheEncounter" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                           </high>
                        </operand>
                     </operand>
                     <operand locator="96:41-96:54" xsi:type="Not">
                        <operand locator="96:41-96:54" xsi:type="IsNull">
                           <operand localId="169" locator="96:69-96:120" xsi:type="Start">
                              <operand localId="168" locator="96:78-96:120" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="167" locator="96:101-96:119" path="period" xsi:type="Property">
                                    <source localId="166" locator="96:101-96:112" name="TheEncounter" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                           </operand>
                        </operand>
                     </operand>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="TheEncounter">
            <operandTypeSpecifier localId="156" locator="92:41-92:54" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="198" locator="99:1-103:116" name="Hospitalization" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="198">
               <a:s>define function &quot;Hospitalization&quot;(TheEncounter </a:s>
               <a:s r="176">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="197">
                  <a:s r="197">
                     <a:s>
                        <a:s r="179">
                           <a:s r="178">
                              <a:s>( </a:s>
                              <a:s r="178">
                                 <a:s>&quot;ED Visit&quot;(</a:s>
                                 <a:s r="177">
                                    <a:s>TheEncounter</a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s> )</a:s>
                           </a:s>
                           <a:s> X</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
    </a:s>
                     <a:s r="196">
                        <a:s>return&#xd;
        </a:s>
                        <a:s r="195">
                           <a:s>if </a:s>
                           <a:s r="181">
                              <a:s r="180">
                                 <a:s>X</a:s>
                              </a:s>
                              <a:s> is null</a:s>
                           </a:s>
                           <a:s> then </a:s>
                           <a:s r="183">
                              <a:s r="182">
                                 <a:s>TheEncounter</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="183">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
        else </a:s>
                           <a:s r="194">
                              <a:s>Interval[</a:s>
                              <a:s r="188">
                                 <a:s>start of </a:s>
                                 <a:s r="187">
                                    <a:s r="184">
                                       <a:s>FHIRHelpers</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="187">
                                       <a:s>ToInterval(</a:s>
                                       <a:s r="186">
                                          <a:s r="185">
                                             <a:s>X</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="186">
                                             <a:s>period</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="193">
                                 <a:s>end of </a:s>
                                 <a:s r="192">
                                    <a:s r="189">
                                       <a:s>FHIRHelpers</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="192">
                                       <a:s>ToInterval(</a:s>
                                       <a:s r="191">
                                          <a:s r="190">
                                             <a:s>TheEncounter</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="191">
                                             <a:s>period</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="197" locator="100:2-103:116" xsi:type="Query">
            <source localId="179" locator="100:2-100:31" alias="X">
               <expression localId="178" locator="100:2-100:29" name="ED Visit" xsi:type="FunctionRef">
                  <operand localId="177" locator="100:15-100:26" name="TheEncounter" xsi:type="OperandRef"/>
               </expression>
            </source>
            <return localId="196" locator="101:5-103:116">
               <expression localId="195" locator="102:9-103:116" xsi:type="If">
                  <condition asType="t:Boolean" xsi:type="As">
                     <operand localId="181" locator="102:12-102:20" xsi:type="IsNull">
                        <operand localId="180" locator="102:12" name="X" xsi:type="AliasRef"/>
                     </operand>
                  </condition>
                  <then name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="183" locator="102:27-102:45" path="period" xsi:type="Property">
                        <source localId="182" locator="102:27-102:38" name="TheEncounter" xsi:type="OperandRef"/>
                     </operand>
                  </then>
                  <else localId="194" locator="103:14-103:116" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="188" locator="103:23-103:63" xsi:type="Start">
                        <operand localId="187" locator="103:32-103:63" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="186" locator="103:55-103:62" path="period" scope="X" xsi:type="Property"/>
                        </operand>
                     </low>
                     <high localId="193" locator="103:66-103:115" xsi:type="End">
                        <operand localId="192" locator="103:73-103:115" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="191" locator="103:96-103:114" path="period" xsi:type="Property">
                              <source localId="190" locator="103:96-103:107" name="TheEncounter" xsi:type="OperandRef"/>
                           </operand>
                        </operand>
                     </high>
                  </else>
               </expression>
            </return>
         </expression>
         <operand name="TheEncounter">
            <operandTypeSpecifier localId="176" locator="99:48-99:61" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="216" locator="105:1-109:68" name="Hospitalization Locations" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="216">
               <a:s>define function &quot;Hospitalization Locations&quot;(TheEncounter </a:s>
               <a:s r="199">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="215">
                  <a:s r="215">
                     <a:s>
                        <a:s r="202">
                           <a:s r="201">
                              <a:s>( </a:s>
                              <a:s r="201">
                                 <a:s>&quot;ED Visit&quot;(</a:s>
                                 <a:s r="200">
                                    <a:s>TheEncounter</a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s> )</a:s>
                           </a:s>
                           <a:s> EDEncounter</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
    </a:s>
                     <a:s r="214">
                        <a:s>return&#xd;
        </a:s>
                        <a:s r="213">
                           <a:s>if </a:s>
                           <a:s r="204">
                              <a:s r="203">
                                 <a:s>EDEncounter</a:s>
                              </a:s>
                              <a:s> is null</a:s>
                           </a:s>
                           <a:s> then </a:s>
                           <a:s r="206">
                              <a:s r="205">
                                 <a:s>TheEncounter</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="206">
                                 <a:s>location</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
        else </a:s>
                           <a:s r="212">
                              <a:s>flatten </a:s>
                              <a:s r="211">
                                 <a:s>{ </a:s>
                                 <a:s r="208">
                                    <a:s r="207">
                                       <a:s>EDEncounter</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="208">
                                       <a:s>location</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="210">
                                    <a:s r="209">
                                       <a:s>TheEncounter</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="210">
                                       <a:s>location</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="215" locator="106:2-109:68" xsi:type="Query">
            <source localId="202" locator="106:2-106:41" alias="EDEncounter">
               <expression localId="201" locator="106:2-106:29" name="ED Visit" xsi:type="FunctionRef">
                  <operand localId="200" locator="106:15-106:26" name="TheEncounter" xsi:type="OperandRef"/>
               </expression>
            </source>
            <return localId="214" locator="107:5-109:68">
               <expression localId="213" locator="108:9-109:68" xsi:type="If">
                  <condition asType="t:Boolean" xsi:type="As">
                     <operand localId="204" locator="108:12-108:30" xsi:type="IsNull">
                        <operand localId="203" locator="108:12-108:22" name="EDEncounter" xsi:type="AliasRef"/>
                     </operand>
                  </condition>
                  <then localId="206" locator="108:37-108:57" path="location" xsi:type="Property">
                     <source localId="205" locator="108:37-108:48" name="TheEncounter" xsi:type="OperandRef"/>
                  </then>
                  <else localId="212" locator="109:14-109:68" xsi:type="Flatten">
                     <operand localId="211" locator="109:22-109:68" xsi:type="List">
                        <element localId="208" locator="109:24-109:43" path="location" scope="EDEncounter" xsi:type="Property"/>
                        <element localId="210" locator="109:46-109:66" path="location" xsi:type="Property">
                           <source localId="209" locator="109:46-109:57" name="TheEncounter" xsi:type="OperandRef"/>
                        </element>
                     </operand>
                  </else>
               </expression>
            </return>
         </expression>
         <operand name="TheEncounter">
            <operandTypeSpecifier localId="199" locator="105:58-105:71" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="221" locator="111:1-112:46" name="Hospitalization Length of Stay" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="221">
               <a:s>define function &quot;Hospitalization Length of Stay&quot;(TheEncounter </a:s>
               <a:s r="217">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="220">
                  <a:s r="220">
                     <a:s>LengthInDays(</a:s>
                     <a:s r="219">
                        <a:s>&quot;Hospitalization&quot;(</a:s>
                        <a:s r="218">
                           <a:s>TheEncounter</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="220" locator="112:2-112:46" name="LengthInDays" xsi:type="FunctionRef">
            <operand localId="219" locator="112:15-112:45" name="Hospitalization" xsi:type="FunctionRef">
               <operand localId="218" locator="112:33-112:44" name="TheEncounter" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="TheEncounter">
            <operandTypeSpecifier localId="217" locator="111:63-111:76" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="226" locator="114:1-115:41" name="Hospital Admission Time" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="226">
               <a:s>define function &quot;Hospital Admission Time&quot;(TheEncounter </a:s>
               <a:s r="222">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="225">
                  <a:s r="225">
                     <a:s>start of </a:s>
                     <a:s r="224">
                        <a:s>&quot;Hospitalization&quot;(</a:s>
                        <a:s r="223">
                           <a:s>TheEncounter</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="225" locator="115:2-115:41" xsi:type="Start">
            <operand localId="224" locator="115:11-115:41" name="Hospitalization" xsi:type="FunctionRef">
               <operand localId="223" locator="115:29-115:40" name="TheEncounter" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="TheEncounter">
            <operandTypeSpecifier localId="222" locator="114:56-114:69" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="233" locator="117:1-118:51" name="Hospital Discharge Time" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="233">
               <a:s>define function &quot;Hospital Discharge Time&quot;(TheEncounter </a:s>
               <a:s r="227">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="232">
                  <a:s r="232">
                     <a:s>end of </a:s>
                     <a:s r="231">
                        <a:s r="228">
                           <a:s>FHIRHelpers</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="231">
                           <a:s>ToInterval(</a:s>
                           <a:s r="230">
                              <a:s r="229">
                                 <a:s>TheEncounter</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="230">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="232" locator="118:2-118:51" xsi:type="End">
            <operand localId="231" locator="118:9-118:51" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand localId="230" locator="118:32-118:50" path="period" xsi:type="Property">
                  <source localId="229" locator="118:32-118:43" name="TheEncounter" xsi:type="OperandRef"/>
               </operand>
            </operand>
         </expression>
         <operand name="TheEncounter">
            <operandTypeSpecifier localId="227" locator="117:56-117:69" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="250" locator="120:1-124:10" name="Hospital Arrival Time" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="250">
               <a:s>define function &quot;Hospital Arrival Time&quot;(TheEncounter </a:s>
               <a:s r="234">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="249">
                  <a:s r="249">
                     <a:s>start of </a:s>
                     <a:s r="248">
                        <a:s r="235">
                           <a:s>FHIRHelpers</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="248">
                           <a:s>ToInterval(</a:s>
                           <a:s r="247">
                              <a:s r="246">
                                 <a:s>First(&#xd;
	    </a:s>
                                 <a:s r="245">
                                    <a:s>
                                       <a:s r="238">
                                          <a:s r="237">
                                             <a:s>( </a:s>
                                             <a:s r="237">
                                                <a:s>&quot;Hospitalization Locations&quot;(</a:s>
                                                <a:s r="236">
                                                   <a:s>TheEncounter</a:s>
                                                </a:s>
                                                <a:s>)</a:s>
                                             </a:s>
                                             <a:s> )</a:s>
                                          </a:s>
                                          <a:s> HospitalLocation</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>&#xd;
			</a:s>
                                    <a:s r="244">
                                       <a:s>sort by </a:s>
                                       <a:s r="243">
                                          <a:s r="242">
                                             <a:s>start of </a:s>
                                             <a:s r="241">
                                                <a:s r="239">
                                                   <a:s>FHIRHelpers</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="241">
                                                   <a:s>ToInterval(</a:s>
                                                   <a:s r="240">
                                                      <a:s>period</a:s>
                                                   </a:s>
                                                   <a:s>)</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
	)</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="247">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="249" locator="121:2-124:10" xsi:type="Start">
            <operand localId="248" locator="121:11-124:10" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand localId="247" locator="121:34-124:9" path="period" xsi:type="Property">
                  <source localId="246" locator="121:34-124:2" xsi:type="First">
                     <source localId="245" locator="122:6-123:50" xsi:type="Query">
                        <source localId="238" locator="122:6-122:67" alias="HospitalLocation">
                           <expression localId="237" locator="122:6-122:50" name="Hospitalization Locations" xsi:type="FunctionRef">
                              <operand localId="236" locator="122:36-122:47" name="TheEncounter" xsi:type="OperandRef"/>
                           </expression>
                        </source>
                        <sort localId="244" locator="123:4-123:50">
                           <by localId="243" locator="123:12-123:50" direction="asc" xsi:type="ByExpression">
                              <expression localId="242" locator="123:12-123:50" xsi:type="Start">
                                 <operand localId="241" locator="123:21-123:50" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="240" locator="123:44-123:49" name="period" xsi:type="IdentifierRef"/>
                                 </operand>
                              </expression>
                           </by>
                        </sort>
                     </source>
                  </source>
               </operand>
            </operand>
         </expression>
         <operand name="TheEncounter">
            <operandTypeSpecifier localId="234" locator="120:54-120:67" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="303" locator="126:1-137:85" name="HospitalizationWithObservation" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="303">
               <a:s>define function &quot;HospitalizationWithObservation&quot;(TheEncounter </a:s>
               <a:s r="251">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="302">
                  <a:s r="302">
                     <a:s>
                        <a:s r="253">
                           <a:s r="252">
                              <a:s>
                                 <a:s>TheEncounter</a:s>
                              </a:s>
                           </a:s>
                           <a:s> Visit</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s>
                        <a:s>let </a:s>
                        <a:s r="269">
                           <a:s>ObsVisit: </a:s>
                           <a:s r="268">
                              <a:s>Last(</a:s>
                              <a:s r="267">
                                 <a:s>
                                    <a:s r="255">
                                       <a:s r="254">
                                          <a:s r="254">
                                             <a:s>[Encounter: </a:s>
                                             <a:s>
                                                <a:s>&quot;Observation Services&quot;</a:s>
                                             </a:s>
                                             <a:s>]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> LastObs</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
				</a:s>
                                 <a:s r="262">
                                    <a:s>where </a:s>
                                    <a:s r="262">
                                       <a:s r="257">
                                          <a:s r="256">
                                             <a:s>LastObs</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="257">
                                             <a:s>period</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> </a:s>
                                       <a:s r="262">
                                          <a:s>ends </a:s>
                                          <a:s r="261">
                                             <a:s>1 hour</a:s>
                                          </a:s>
                                          <a:s> or less on or before</a:s>
                                       </a:s>
                                       <a:s> </a:s>
                                       <a:s r="260">
                                          <a:s>start of </a:s>
                                          <a:s r="259">
                                             <a:s r="258">
                                                <a:s>Visit</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="259">
                                                <a:s>period</a:s>
                                             </a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
				</a:s>
                                 <a:s r="266">
                                    <a:s>sort by </a:s>
                                    <a:s r="265">
                                       <a:s r="264">
                                          <a:s>end of </a:s>
                                          <a:s r="263">
                                             <a:s>period</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>&#xd;
			)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,&#xd;
			</a:s>
                        <a:s r="277">
                           <a:s>VisitStart: </a:s>
                           <a:s r="276">
                              <a:s>Coalesce(</a:s>
                              <a:s r="272">
                                 <a:s>start of </a:s>
                                 <a:s r="271">
                                    <a:s r="270">
                                       <a:s>ObsVisit</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="271">
                                       <a:s>period</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="275">
                                 <a:s>start of </a:s>
                                 <a:s r="274">
                                    <a:s r="273">
                                       <a:s>Visit</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="274">
                                       <a:s>period</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,&#xd;
			</a:s>
                        <a:s r="291">
                           <a:s>EDVisit: </a:s>
                           <a:s r="290">
                              <a:s>Last(</a:s>
                              <a:s r="289">
                                 <a:s>
                                    <a:s r="279">
                                       <a:s r="278">
                                          <a:s r="278">
                                             <a:s>[Encounter: </a:s>
                                             <a:s>
                                                <a:s>&quot;Emergency Department Visit&quot;</a:s>
                                             </a:s>
                                             <a:s>]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> LastED</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
				</a:s>
                                 <a:s r="284">
                                    <a:s>where </a:s>
                                    <a:s r="284">
                                       <a:s r="281">
                                          <a:s r="280">
                                             <a:s>LastED</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="281">
                                             <a:s>period</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> </a:s>
                                       <a:s r="284">
                                          <a:s>ends </a:s>
                                          <a:s r="283">
                                             <a:s>1 hour</a:s>
                                          </a:s>
                                          <a:s> or less on or before</a:s>
                                       </a:s>
                                       <a:s> </a:s>
                                       <a:s r="282">
                                          <a:s>VisitStart</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
				</a:s>
                                 <a:s r="288">
                                    <a:s>sort by </a:s>
                                    <a:s r="287">
                                       <a:s r="286">
                                          <a:s>end of </a:s>
                                          <a:s r="285">
                                             <a:s>period</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>&#xd;
			)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="301">
                        <a:s>return </a:s>
                        <a:s r="300">
                           <a:s>Interval[</a:s>
                           <a:s r="296">
                              <a:s>Coalesce(</a:s>
                              <a:s r="294">
                                 <a:s>start of </a:s>
                                 <a:s r="293">
                                    <a:s r="292">
                                       <a:s>EDVisit</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="293">
                                       <a:s>period</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="295">
                                 <a:s>VisitStart</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="299">
                              <a:s>end of </a:s>
                              <a:s r="298">
                                 <a:s r="297">
                                    <a:s>Visit</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="298">
                                    <a:s>period</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="302" locator="127:2-137:85" xsi:type="Query">
            <source localId="253" locator="127:2-127:19" alias="Visit">
               <expression localId="252" locator="127:2-127:13" name="TheEncounter" xsi:type="OperandRef"/>
            </source>
            <let localId="269" locator="128:7-131:4" identifier="ObsVisit">
               <expression localId="268" locator="128:17-131:4" xsi:type="Last">
                  <source localId="267" locator="128:22-130:25" xsi:type="Query">
                     <source localId="255" locator="128:22-128:64" alias="LastObs">
                        <expression localId="254" locator="128:22-128:56" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                           <codes locator="128:34-128:55" name="Observation Services" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="262" locator="129:5-129:79" xsi:type="And">
                        <operand locator="129:31-129:44" xsi:type="In">
                           <operand locator="129:26-129:29" xsi:type="End">
                              <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="257" locator="129:11-129:24" path="period" scope="LastObs" xsi:type="Property"/>
                              </operand>
                           </operand>
                           <operand locator="129:31-129:44" lowClosed="true" highClosed="true" xsi:type="Interval">
                              <low locator="129:59-129:79" xsi:type="Subtract">
                                 <operand localId="260" locator="129:59-129:79" xsi:type="Start">
                                    <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="259" locator="129:68-129:79" path="period" scope="Visit" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <operand localId="261" locator="129:31-129:36" value="1" unit="hour" xsi:type="Quantity"/>
                              </low>
                              <high localId="260" locator="129:59-129:79" xsi:type="Start">
                                 <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="259" locator="129:68-129:79" path="period" scope="Visit" xsi:type="Property"/>
                                 </operand>
                              </high>
                           </operand>
                        </operand>
                        <operand locator="129:31-129:44" xsi:type="Not">
                           <operand locator="129:31-129:44" xsi:type="IsNull">
                              <operand localId="260" locator="129:59-129:79" xsi:type="Start">
                                 <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="259" locator="129:68-129:79" path="period" scope="Visit" xsi:type="Property"/>
                                 </operand>
                              </operand>
                           </operand>
                        </operand>
                     </where>
                     <sort localId="266" locator="130:5-130:25">
                        <by localId="265" locator="130:13-130:25" direction="asc" xsi:type="ByExpression">
                           <expression localId="264" locator="130:13-130:25" xsi:type="End">
                              <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="263" locator="130:20-130:25" name="period" xsi:type="IdentifierRef"/>
                              </operand>
                           </expression>
                        </by>
                     </sort>
                  </source>
               </expression>
            </let>
            <let localId="277" locator="132:4-132:72" identifier="VisitStart">
               <expression localId="276" locator="132:16-132:72" xsi:type="Coalesce">
                  <operand localId="272" locator="132:25-132:48" xsi:type="Start">
                     <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="271" locator="132:34-132:48" path="period" xsi:type="Property">
                           <source localId="270" locator="132:34-132:41" name="ObsVisit" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="275" locator="132:51-132:71" xsi:type="Start">
                     <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="274" locator="132:60-132:71" path="period" scope="Visit" xsi:type="Property"/>
                     </operand>
                  </operand>
               </expression>
            </let>
            <let localId="291" locator="133:4-136:4" identifier="EDVisit">
               <expression localId="290" locator="133:13-136:4" xsi:type="Last">
                  <source localId="289" locator="133:18-135:25" xsi:type="Query">
                     <source localId="279" locator="133:18-133:65" alias="LastED">
                        <expression localId="278" locator="133:18-133:58" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                           <codes locator="133:30-133:57" name="Emergency Department Visit" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="284" locator="134:5-134:67" xsi:type="And">
                        <operand locator="134:30-134:43" xsi:type="In">
                           <operand locator="134:25-134:28" xsi:type="End">
                              <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="281" locator="134:11-134:23" path="period" scope="LastED" xsi:type="Property"/>
                              </operand>
                           </operand>
                           <operand locator="134:30-134:43" lowClosed="true" highClosed="true" xsi:type="Interval">
                              <low locator="134:58-134:67" xsi:type="Subtract">
                                 <operand localId="282" locator="134:58-134:67" name="VisitStart" xsi:type="QueryLetRef"/>
                                 <operand localId="283" locator="134:30-134:35" value="1" unit="hour" xsi:type="Quantity"/>
                              </low>
                              <high localId="282" locator="134:58-134:67" name="VisitStart" xsi:type="QueryLetRef"/>
                           </operand>
                        </operand>
                        <operand locator="134:30-134:43" xsi:type="Not">
                           <operand locator="134:30-134:43" xsi:type="IsNull">
                              <operand localId="282" locator="134:58-134:67" name="VisitStart" xsi:type="QueryLetRef"/>
                           </operand>
                        </operand>
                     </where>
                     <sort localId="288" locator="135:5-135:25">
                        <by localId="287" locator="135:13-135:25" direction="asc" xsi:type="ByExpression">
                           <expression localId="286" locator="135:13-135:25" xsi:type="End">
                              <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="285" locator="135:20-135:25" name="period" xsi:type="IdentifierRef"/>
                              </operand>
                           </expression>
                        </by>
                     </sort>
                  </source>
               </expression>
            </let>
            <return localId="301" locator="137:3-137:85">
               <expression localId="300" locator="137:10-137:85" lowClosed="true" highClosed="true" xsi:type="Interval">
                  <low localId="296" locator="137:19-137:63" xsi:type="Coalesce">
                     <operand localId="294" locator="137:28-137:50" xsi:type="Start">
                        <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="293" locator="137:37-137:50" path="period" xsi:type="Property">
                              <source localId="292" locator="137:37-137:43" name="EDVisit" xsi:type="QueryLetRef"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="295" locator="137:53-137:62" name="VisitStart" xsi:type="QueryLetRef"/>
                  </low>
                  <high localId="299" locator="137:66-137:84" xsi:type="End">
                     <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="298" locator="137:73-137:84" path="period" scope="Visit" xsi:type="Property"/>
                     </operand>
                  </high>
               </expression>
            </return>
         </expression>
         <operand name="TheEncounter">
            <operandTypeSpecifier localId="251" locator="126:63-126:76" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="308" locator="139:1-140:60" name="HospitalizationWithObservationLengthofStay" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="308">
               <a:s>define function &quot;HospitalizationWithObservationLengthofStay&quot;(Encounter </a:s>
               <a:s r="304">
                  <a:s>FHIR.Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="307">
                  <a:s r="307">
                     <a:s>&quot;LengthInDays&quot;(</a:s>
                     <a:s r="306">
                        <a:s>&quot;HospitalizationWithObservation&quot;(</a:s>
                        <a:s r="305">
                           <a:s>Encounter</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="307" locator="140:2-140:60" name="LengthInDays" xsi:type="FunctionRef">
            <operand localId="306" locator="140:17-140:59" name="HospitalizationWithObservation" xsi:type="FunctionRef">
               <operand localId="305" locator="140:50-140:58" name="Encounter" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="Encounter">
            <operandTypeSpecifier localId="304" locator="139:72-139:85" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="443" locator="171:1-191:4" name="Normalize Interval" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="443">
               <a:s>define function &quot;Normalize Interval&quot;(choice </a:s>
               <a:s r="316">
                  <a:s>Choice&lt;</a:s>
                  <a:s r="309">
                     <a:s>FHIR.dateTime</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="310">
                     <a:s>FHIR.Period</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="311">
                     <a:s>FHIR.Timing</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="312">
                     <a:s>FHIR.instant</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="313">
                     <a:s>FHIR.string</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="314">
                     <a:s>FHIR.Age</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="315">
                     <a:s>FHIR.Range</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="442">
                  <a:s r="442">
                     <a:s>case&#xd;
	  </a:s>
                     <a:s r="331">
                        <a:s>when </a:s>
                        <a:s r="319">
                           <a:s r="317">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="318">
                              <a:s>FHIR.dateTime</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then&#xd;
    	</a:s>
                        <a:s r="330">
                           <a:s>Interval[</a:s>
                           <a:s r="324">
                              <a:s r="320">
                                 <a:s>FHIRHelpers</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="324">
                                 <a:s>ToDateTime(</a:s>
                                 <a:s r="323">
                                    <a:s r="321">
                                       <a:s>choice</a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="322">
                                       <a:s>FHIR.dateTime</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="329">
                              <a:s r="325">
                                 <a:s>FHIRHelpers</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="329">
                                 <a:s>ToDateTime(</a:s>
                                 <a:s r="328">
                                    <a:s r="326">
                                       <a:s>choice</a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="327">
                                       <a:s>FHIR.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>&#xd;
		</a:s>
                     <a:s r="340">
                        <a:s>when </a:s>
                        <a:s r="334">
                           <a:s r="332">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="333">
                              <a:s>FHIR.Period</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then&#xd;
  		</a:s>
                        <a:s r="339">
                           <a:s r="335">
                              <a:s>FHIRHelpers</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="339">
                              <a:s>ToInterval(</a:s>
                              <a:s r="338">
                                 <a:s r="336">
                                    <a:s>choice</a:s>
                                 </a:s>
                                 <a:s> as </a:s>
                                 <a:s r="337">
                                    <a:s>FHIR.Period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="355">
                        <a:s>when </a:s>
                        <a:s r="343">
                           <a:s r="341">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="342">
                              <a:s>FHIR.instant</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then&#xd;
			</a:s>
                        <a:s r="354">
                           <a:s>Interval[</a:s>
                           <a:s r="348">
                              <a:s r="344">
                                 <a:s>FHIRHelpers</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="348">
                                 <a:s>ToDateTime(</a:s>
                                 <a:s r="347">
                                    <a:s r="345">
                                       <a:s>choice</a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="346">
                                       <a:s>FHIR.instant</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="353">
                              <a:s r="349">
                                 <a:s>FHIRHelpers</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="353">
                                 <a:s>ToDateTime(</a:s>
                                 <a:s r="352">
                                    <a:s r="350">
                                       <a:s>choice</a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="351">
                                       <a:s>FHIR.instant</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s>]</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="382">
                        <a:s>when </a:s>
                        <a:s r="358">
                           <a:s r="356">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="357">
                              <a:s>FHIR.Age</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then&#xd;
		  </a:s>
                        <a:s r="381">
                           <a:s>Interval[</a:s>
                           <a:s r="368">
                              <a:s r="362">
                                 <a:s r="359">
                                    <a:s>FHIRHelpers</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="362">
                                    <a:s>ToDate(</a:s>
                                    <a:s r="361">
                                       <a:s r="360">
                                          <a:s>Patient</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="361">
                                          <a:s>birthDate</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="367">
                                 <a:s r="363">
                                    <a:s>FHIRHelpers</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="367">
                                    <a:s>ToQuantity(</a:s>
                                    <a:s r="366">
                                       <a:s r="364">
                                          <a:s>choice</a:s>
                                       </a:s>
                                       <a:s> as </a:s>
                                       <a:s r="365">
                                          <a:s>FHIR.Age</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>,&#xd;
			  </a:s>
                           <a:s r="380">
                              <a:s r="378">
                                 <a:s r="372">
                                    <a:s r="369">
                                       <a:s>FHIRHelpers</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="372">
                                       <a:s>ToDate(</a:s>
                                       <a:s r="371">
                                          <a:s r="370">
                                             <a:s>Patient</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="371">
                                             <a:s>birthDate</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="377">
                                    <a:s r="373">
                                       <a:s>FHIRHelpers</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="377">
                                       <a:s>ToQuantity(</a:s>
                                       <a:s r="376">
                                          <a:s r="374">
                                             <a:s>choice</a:s>
                                          </a:s>
                                          <a:s> as </a:s>
                                          <a:s r="375">
                                             <a:s>FHIR.Age</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="379">
                                 <a:s>1 year</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="411">
                        <a:s>when </a:s>
                        <a:s r="385">
                           <a:s r="383">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="384">
                              <a:s>FHIR.Range</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then&#xd;
		  </a:s>
                        <a:s r="410">
                           <a:s>Interval[</a:s>
                           <a:s r="396">
                              <a:s r="389">
                                 <a:s r="386">
                                    <a:s>FHIRHelpers</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="389">
                                    <a:s>ToDate(</a:s>
                                    <a:s r="388">
                                       <a:s r="387">
                                          <a:s>Patient</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="388">
                                          <a:s>birthDate</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="395">
                                 <a:s r="390">
                                    <a:s>FHIRHelpers</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="395">
                                    <a:s>ToQuantity(</a:s>
                                    <a:s r="394">
                                       <a:s r="393">
                                          <a:s>(</a:s>
                                          <a:s r="393">
                                             <a:s r="391">
                                                <a:s>choice</a:s>
                                             </a:s>
                                             <a:s> as </a:s>
                                             <a:s r="392">
                                                <a:s>FHIR.Range</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>)</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="394">
                                          <a:s>low</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>,&#xd;
			  </a:s>
                           <a:s r="409">
                              <a:s r="407">
                                 <a:s r="400">
                                    <a:s r="397">
                                       <a:s>FHIRHelpers</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="400">
                                       <a:s>ToDate(</a:s>
                                       <a:s r="399">
                                          <a:s r="398">
                                             <a:s>Patient</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="399">
                                             <a:s>birthDate</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="406">
                                    <a:s r="401">
                                       <a:s>FHIRHelpers</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="406">
                                       <a:s>ToQuantity(</a:s>
                                       <a:s r="405">
                                          <a:s r="404">
                                             <a:s>(</a:s>
                                             <a:s r="404">
                                                <a:s r="402">
                                                   <a:s>choice</a:s>
                                                </a:s>
                                                <a:s> as </a:s>
                                                <a:s r="403">
                                                   <a:s>FHIR.Range</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="405">
                                             <a:s>high</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="408">
                                 <a:s>1 year</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="424">
                        <a:s>when </a:s>
                        <a:s r="414">
                           <a:s r="412">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="413">
                              <a:s>FHIR.Timing</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then&#xd;
		  </a:s>
                        <a:s r="423">
                           <a:s>Message(</a:s>
                           <a:s r="418">
                              <a:s r="415">null as </a:s>
                              <a:s r="417">
                                 <a:s>Interval&lt;</a:s>
                                 <a:s r="416">
                                    <a:s>DateTime</a:s>
                                 </a:s>
                                 <a:s>></a:s>
                              </a:s>
                           </a:s>
                           <a:s r="419">, true, </a:s>
                           <a:s r="420">
                              <a:s>'1'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="421">
                              <a:s>'Error'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="422">
                              <a:s>'Cannot compute a single interval from a Timing type'</a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
    </a:s>
                     <a:s r="437">
                        <a:s>when </a:s>
                        <a:s r="427">
                           <a:s r="425">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="426">
                              <a:s>FHIR.string</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then&#xd;
      </a:s>
                        <a:s r="436">
                           <a:s>Message(</a:s>
                           <a:s r="431">
                              <a:s r="428">null as </a:s>
                              <a:s r="430">
                                 <a:s>Interval&lt;</a:s>
                                 <a:s r="429">
                                    <a:s>DateTime</a:s>
                                 </a:s>
                                 <a:s>></a:s>
                              </a:s>
                           </a:s>
                           <a:s r="432">, true, </a:s>
                           <a:s r="433">
                              <a:s>'1'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="434">
                              <a:s>'Error'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="435">
                              <a:s>'Cannot compute an interval from a String value'</a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		else&#xd;
			</a:s>
                     <a:s r="441">
                        <a:s r="438">null as </a:s>
                        <a:s r="440">
                           <a:s>Interval&lt;</a:s>
                           <a:s r="439">
                              <a:s>DateTime</a:s>
                           </a:s>
                           <a:s>></a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
	end</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="442" locator="172:3-191:4" xsi:type="Case">
            <caseItem localId="331" locator="173:4-174:111">
               <when localId="319" locator="173:9-173:31" xsi:type="Is">
                  <operand localId="317" locator="173:9-173:14" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="318" locator="173:19-173:31" name="fhir:dateTime" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then localId="330" locator="174:6-174:111" lowClosed="true" highClosed="true" xsi:type="Interval">
                  <low localId="324" locator="174:15-174:61" name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="323" locator="174:38-174:60" strict="false" xsi:type="As">
                        <operand localId="321" locator="174:38-174:43" name="choice" xsi:type="OperandRef"/>
                        <asTypeSpecifier localId="322" locator="174:48-174:60" name="fhir:dateTime" xsi:type="NamedTypeSpecifier"/>
                     </operand>
                  </low>
                  <high localId="329" locator="174:64-174:110" name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="328" locator="174:87-174:109" strict="false" xsi:type="As">
                        <operand localId="326" locator="174:87-174:92" name="choice" xsi:type="OperandRef"/>
                        <asTypeSpecifier localId="327" locator="174:97-174:109" name="fhir:dateTime" xsi:type="NamedTypeSpecifier"/>
                     </operand>
                  </high>
               </then>
            </caseItem>
            <caseItem localId="340" locator="175:3-176:49">
               <when localId="334" locator="175:8-175:28" xsi:type="Is">
                  <operand localId="332" locator="175:8-175:13" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="333" locator="175:18-175:28" name="fhir:Period" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then localId="339" locator="176:5-176:49" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="338" locator="176:28-176:48" strict="false" xsi:type="As">
                     <operand localId="336" locator="176:28-176:33" name="choice" xsi:type="OperandRef"/>
                     <asTypeSpecifier localId="337" locator="176:38-176:48" name="fhir:Period" xsi:type="NamedTypeSpecifier"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="355" locator="177:3-178:107">
               <when localId="343" locator="177:8-177:29" xsi:type="Is">
                  <operand localId="341" locator="177:8-177:13" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="342" locator="177:18-177:29" name="fhir:instant" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then localId="354" locator="178:4-178:107" lowClosed="true" highClosed="true" xsi:type="Interval">
                  <low localId="348" locator="178:13-178:58" name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="347" locator="178:36-178:57" strict="false" xsi:type="As">
                        <operand localId="345" locator="178:36-178:41" name="choice" xsi:type="OperandRef"/>
                        <asTypeSpecifier localId="346" locator="178:46-178:57" name="fhir:instant" xsi:type="NamedTypeSpecifier"/>
                     </operand>
                  </low>
                  <high localId="353" locator="178:61-178:106" name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="352" locator="178:84-178:105" strict="false" xsi:type="As">
                        <operand localId="350" locator="178:84-178:89" name="choice" xsi:type="OperandRef"/>
                        <asTypeSpecifier localId="351" locator="178:94-178:105" name="fhir:instant" xsi:type="NamedTypeSpecifier"/>
                     </operand>
                  </high>
               </then>
            </caseItem>
            <caseItem localId="382" locator="179:3-181:97">
               <when localId="358" locator="179:8-179:25" xsi:type="Is">
                  <operand localId="356" locator="179:8-179:13" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="357" locator="179:18-179:25" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then xsi:type="Interval">
                  <low xsi:type="ToDateTime">
                     <operand path="low" xsi:type="Property">
                        <source localId="381" locator="180:5-181:97" lowClosed="true" highClosed="false" xsi:type="Interval">
                           <low localId="368" locator="180:14-180:95" xsi:type="Add">
                              <operand localId="362" locator="180:14-180:50" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="361" locator="180:33-180:49" path="birthDate" xsi:type="Property">
                                    <source localId="360" locator="180:33-180:39" name="Patient" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="367" locator="180:54-180:95" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="366" locator="180:77-180:94" strict="false" xsi:type="As">
                                    <operand localId="364" locator="180:77-180:82" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="365" locator="180:87-180:94" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </low>
                           <high localId="380" locator="181:6-181:96" xsi:type="Add">
                              <operand localId="378" locator="181:6-181:87" xsi:type="Add">
                                 <operand localId="372" locator="181:6-181:42" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="371" locator="181:25-181:41" path="birthDate" xsi:type="Property">
                                       <source localId="370" locator="181:25-181:31" name="Patient" xsi:type="ExpressionRef"/>
                                    </operand>
                                 </operand>
                                 <operand localId="377" locator="181:46-181:87" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="376" locator="181:69-181:86" strict="false" xsi:type="As">
                                       <operand localId="374" locator="181:69-181:74" name="choice" xsi:type="OperandRef"/>
                                       <asTypeSpecifier localId="375" locator="181:79-181:86" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="379" locator="181:91-181:96" value="1" unit="year" xsi:type="Quantity"/>
                           </high>
                        </source>
                     </operand>
                  </low>
                  <lowClosedExpression path="lowClosed" xsi:type="Property">
                     <source localId="381" locator="180:5-181:97" lowClosed="true" highClosed="false" xsi:type="Interval">
                        <low localId="368" locator="180:14-180:95" xsi:type="Add">
                           <operand localId="362" locator="180:14-180:50" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="361" locator="180:33-180:49" path="birthDate" xsi:type="Property">
                                 <source localId="360" locator="180:33-180:39" name="Patient" xsi:type="ExpressionRef"/>
                              </operand>
                           </operand>
                           <operand localId="367" locator="180:54-180:95" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="366" locator="180:77-180:94" strict="false" xsi:type="As">
                                 <operand localId="364" locator="180:77-180:82" name="choice" xsi:type="OperandRef"/>
                                 <asTypeSpecifier localId="365" locator="180:87-180:94" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                              </operand>
                           </operand>
                        </low>
                        <high localId="380" locator="181:6-181:96" xsi:type="Add">
                           <operand localId="378" locator="181:6-181:87" xsi:type="Add">
                              <operand localId="372" locator="181:6-181:42" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="371" locator="181:25-181:41" path="birthDate" xsi:type="Property">
                                    <source localId="370" locator="181:25-181:31" name="Patient" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="377" locator="181:46-181:87" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="376" locator="181:69-181:86" strict="false" xsi:type="As">
                                    <operand localId="374" locator="181:69-181:74" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="375" locator="181:79-181:86" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </operand>
                           <operand localId="379" locator="181:91-181:96" value="1" unit="year" xsi:type="Quantity"/>
                        </high>
                     </source>
                  </lowClosedExpression>
                  <high xsi:type="ToDateTime">
                     <operand path="high" xsi:type="Property">
                        <source localId="381" locator="180:5-181:97" lowClosed="true" highClosed="false" xsi:type="Interval">
                           <low localId="368" locator="180:14-180:95" xsi:type="Add">
                              <operand localId="362" locator="180:14-180:50" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="361" locator="180:33-180:49" path="birthDate" xsi:type="Property">
                                    <source localId="360" locator="180:33-180:39" name="Patient" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="367" locator="180:54-180:95" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="366" locator="180:77-180:94" strict="false" xsi:type="As">
                                    <operand localId="364" locator="180:77-180:82" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="365" locator="180:87-180:94" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </low>
                           <high localId="380" locator="181:6-181:96" xsi:type="Add">
                              <operand localId="378" locator="181:6-181:87" xsi:type="Add">
                                 <operand localId="372" locator="181:6-181:42" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="371" locator="181:25-181:41" path="birthDate" xsi:type="Property">
                                       <source localId="370" locator="181:25-181:31" name="Patient" xsi:type="ExpressionRef"/>
                                    </operand>
                                 </operand>
                                 <operand localId="377" locator="181:46-181:87" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="376" locator="181:69-181:86" strict="false" xsi:type="As">
                                       <operand localId="374" locator="181:69-181:74" name="choice" xsi:type="OperandRef"/>
                                       <asTypeSpecifier localId="375" locator="181:79-181:86" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="379" locator="181:91-181:96" value="1" unit="year" xsi:type="Quantity"/>
                           </high>
                        </source>
                     </operand>
                  </high>
                  <highClosedExpression path="highClosed" xsi:type="Property">
                     <source localId="381" locator="180:5-181:97" lowClosed="true" highClosed="false" xsi:type="Interval">
                        <low localId="368" locator="180:14-180:95" xsi:type="Add">
                           <operand localId="362" locator="180:14-180:50" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="361" locator="180:33-180:49" path="birthDate" xsi:type="Property">
                                 <source localId="360" locator="180:33-180:39" name="Patient" xsi:type="ExpressionRef"/>
                              </operand>
                           </operand>
                           <operand localId="367" locator="180:54-180:95" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="366" locator="180:77-180:94" strict="false" xsi:type="As">
                                 <operand localId="364" locator="180:77-180:82" name="choice" xsi:type="OperandRef"/>
                                 <asTypeSpecifier localId="365" locator="180:87-180:94" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                              </operand>
                           </operand>
                        </low>
                        <high localId="380" locator="181:6-181:96" xsi:type="Add">
                           <operand localId="378" locator="181:6-181:87" xsi:type="Add">
                              <operand localId="372" locator="181:6-181:42" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="371" locator="181:25-181:41" path="birthDate" xsi:type="Property">
                                    <source localId="370" locator="181:25-181:31" name="Patient" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="377" locator="181:46-181:87" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="376" locator="181:69-181:86" strict="false" xsi:type="As">
                                    <operand localId="374" locator="181:69-181:74" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="375" locator="181:79-181:86" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </operand>
                           <operand localId="379" locator="181:91-181:96" value="1" unit="year" xsi:type="Quantity"/>
                        </high>
                     </source>
                  </highClosedExpression>
               </then>
            </caseItem>
            <caseItem localId="411" locator="182:3-184:106">
               <when localId="385" locator="182:8-182:27" xsi:type="Is">
                  <operand localId="383" locator="182:8-182:13" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="384" locator="182:18-182:27" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then xsi:type="Interval">
                  <low xsi:type="ToDateTime">
                     <operand path="low" xsi:type="Property">
                        <source localId="410" locator="183:5-184:106" lowClosed="true" highClosed="false" xsi:type="Interval">
                           <low localId="396" locator="183:14-183:103" xsi:type="Add">
                              <operand localId="389" locator="183:14-183:50" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="388" locator="183:33-183:49" path="birthDate" xsi:type="Property">
                                    <source localId="387" locator="183:33-183:39" name="Patient" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="395" locator="183:54-183:103" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="394" locator="183:77-183:102" path="low" xsi:type="Property">
                                    <source localId="393" locator="183:77-183:98" strict="false" xsi:type="As">
                                       <operand localId="391" locator="183:78-183:83" name="choice" xsi:type="OperandRef"/>
                                       <asTypeSpecifier localId="392" locator="183:88-183:97" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                    </source>
                                 </operand>
                              </operand>
                           </low>
                           <high localId="409" locator="184:6-184:105" xsi:type="Add">
                              <operand localId="407" locator="184:6-184:96" xsi:type="Add">
                                 <operand localId="400" locator="184:6-184:42" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="399" locator="184:25-184:41" path="birthDate" xsi:type="Property">
                                       <source localId="398" locator="184:25-184:31" name="Patient" xsi:type="ExpressionRef"/>
                                    </operand>
                                 </operand>
                                 <operand localId="406" locator="184:46-184:96" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="405" locator="184:69-184:95" path="high" xsi:type="Property">
                                       <source localId="404" locator="184:69-184:90" strict="false" xsi:type="As">
                                          <operand localId="402" locator="184:70-184:75" name="choice" xsi:type="OperandRef"/>
                                          <asTypeSpecifier localId="403" locator="184:80-184:89" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                       </source>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="408" locator="184:100-184:105" value="1" unit="year" xsi:type="Quantity"/>
                           </high>
                        </source>
                     </operand>
                  </low>
                  <lowClosedExpression path="lowClosed" xsi:type="Property">
                     <source localId="410" locator="183:5-184:106" lowClosed="true" highClosed="false" xsi:type="Interval">
                        <low localId="396" locator="183:14-183:103" xsi:type="Add">
                           <operand localId="389" locator="183:14-183:50" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="388" locator="183:33-183:49" path="birthDate" xsi:type="Property">
                                 <source localId="387" locator="183:33-183:39" name="Patient" xsi:type="ExpressionRef"/>
                              </operand>
                           </operand>
                           <operand localId="395" locator="183:54-183:103" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="394" locator="183:77-183:102" path="low" xsi:type="Property">
                                 <source localId="393" locator="183:77-183:98" strict="false" xsi:type="As">
                                    <operand localId="391" locator="183:78-183:83" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="392" locator="183:88-183:97" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                 </source>
                              </operand>
                           </operand>
                        </low>
                        <high localId="409" locator="184:6-184:105" xsi:type="Add">
                           <operand localId="407" locator="184:6-184:96" xsi:type="Add">
                              <operand localId="400" locator="184:6-184:42" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="399" locator="184:25-184:41" path="birthDate" xsi:type="Property">
                                    <source localId="398" locator="184:25-184:31" name="Patient" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="406" locator="184:46-184:96" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="405" locator="184:69-184:95" path="high" xsi:type="Property">
                                    <source localId="404" locator="184:69-184:90" strict="false" xsi:type="As">
                                       <operand localId="402" locator="184:70-184:75" name="choice" xsi:type="OperandRef"/>
                                       <asTypeSpecifier localId="403" locator="184:80-184:89" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                    </source>
                                 </operand>
                              </operand>
                           </operand>
                           <operand localId="408" locator="184:100-184:105" value="1" unit="year" xsi:type="Quantity"/>
                        </high>
                     </source>
                  </lowClosedExpression>
                  <high xsi:type="ToDateTime">
                     <operand path="high" xsi:type="Property">
                        <source localId="410" locator="183:5-184:106" lowClosed="true" highClosed="false" xsi:type="Interval">
                           <low localId="396" locator="183:14-183:103" xsi:type="Add">
                              <operand localId="389" locator="183:14-183:50" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="388" locator="183:33-183:49" path="birthDate" xsi:type="Property">
                                    <source localId="387" locator="183:33-183:39" name="Patient" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="395" locator="183:54-183:103" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="394" locator="183:77-183:102" path="low" xsi:type="Property">
                                    <source localId="393" locator="183:77-183:98" strict="false" xsi:type="As">
                                       <operand localId="391" locator="183:78-183:83" name="choice" xsi:type="OperandRef"/>
                                       <asTypeSpecifier localId="392" locator="183:88-183:97" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                    </source>
                                 </operand>
                              </operand>
                           </low>
                           <high localId="409" locator="184:6-184:105" xsi:type="Add">
                              <operand localId="407" locator="184:6-184:96" xsi:type="Add">
                                 <operand localId="400" locator="184:6-184:42" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="399" locator="184:25-184:41" path="birthDate" xsi:type="Property">
                                       <source localId="398" locator="184:25-184:31" name="Patient" xsi:type="ExpressionRef"/>
                                    </operand>
                                 </operand>
                                 <operand localId="406" locator="184:46-184:96" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="405" locator="184:69-184:95" path="high" xsi:type="Property">
                                       <source localId="404" locator="184:69-184:90" strict="false" xsi:type="As">
                                          <operand localId="402" locator="184:70-184:75" name="choice" xsi:type="OperandRef"/>
                                          <asTypeSpecifier localId="403" locator="184:80-184:89" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                       </source>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="408" locator="184:100-184:105" value="1" unit="year" xsi:type="Quantity"/>
                           </high>
                        </source>
                     </operand>
                  </high>
                  <highClosedExpression path="highClosed" xsi:type="Property">
                     <source localId="410" locator="183:5-184:106" lowClosed="true" highClosed="false" xsi:type="Interval">
                        <low localId="396" locator="183:14-183:103" xsi:type="Add">
                           <operand localId="389" locator="183:14-183:50" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="388" locator="183:33-183:49" path="birthDate" xsi:type="Property">
                                 <source localId="387" locator="183:33-183:39" name="Patient" xsi:type="ExpressionRef"/>
                              </operand>
                           </operand>
                           <operand localId="395" locator="183:54-183:103" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="394" locator="183:77-183:102" path="low" xsi:type="Property">
                                 <source localId="393" locator="183:77-183:98" strict="false" xsi:type="As">
                                    <operand localId="391" locator="183:78-183:83" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="392" locator="183:88-183:97" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                 </source>
                              </operand>
                           </operand>
                        </low>
                        <high localId="409" locator="184:6-184:105" xsi:type="Add">
                           <operand localId="407" locator="184:6-184:96" xsi:type="Add">
                              <operand localId="400" locator="184:6-184:42" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="399" locator="184:25-184:41" path="birthDate" xsi:type="Property">
                                    <source localId="398" locator="184:25-184:31" name="Patient" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="406" locator="184:46-184:96" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="405" locator="184:69-184:95" path="high" xsi:type="Property">
                                    <source localId="404" locator="184:69-184:90" strict="false" xsi:type="As">
                                       <operand localId="402" locator="184:70-184:75" name="choice" xsi:type="OperandRef"/>
                                       <asTypeSpecifier localId="403" locator="184:80-184:89" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                    </source>
                                 </operand>
                              </operand>
                           </operand>
                           <operand localId="408" locator="184:100-184:105" value="1" unit="year" xsi:type="Quantity"/>
                        </high>
                     </source>
                  </highClosedExpression>
               </then>
            </caseItem>
            <caseItem localId="424" locator="185:3-186:114">
               <when localId="414" locator="185:8-185:28" xsi:type="Is">
                  <operand localId="412" locator="185:8-185:13" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="413" locator="185:18-185:28" name="fhir:Timing" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then localId="423" locator="186:5-186:114" xsi:type="Message">
                  <source localId="418" locator="186:13-186:38" strict="false" xsi:type="As">
                     <operand localId="415" locator="186:13-186:16" xsi:type="Null"/>
                     <asTypeSpecifier localId="417" locator="186:21-186:38" xsi:type="IntervalTypeSpecifier">
                        <pointType localId="416" locator="186:30-186:37" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                     </asTypeSpecifier>
                  </source>
                  <condition localId="419" locator="186:41-186:44" valueType="t:Boolean" value="true" xsi:type="Literal"/>
                  <code localId="420" locator="186:47-186:49" valueType="t:String" value="1" xsi:type="Literal"/>
                  <severity localId="421" locator="186:52-186:58" valueType="t:String" value="Error" xsi:type="Literal"/>
                  <message localId="422" locator="186:61-186:113" valueType="t:String" value="Cannot compute a single interval from a Timing type" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="437" locator="187:5-188:111">
               <when localId="427" locator="187:10-187:30" xsi:type="Is">
                  <operand localId="425" locator="187:10-187:15" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="426" locator="187:20-187:30" name="fhir:string" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then localId="436" locator="188:7-188:111" xsi:type="Message">
                  <source localId="431" locator="188:15-188:40" strict="false" xsi:type="As">
                     <operand localId="428" locator="188:15-188:18" xsi:type="Null"/>
                     <asTypeSpecifier localId="430" locator="188:23-188:40" xsi:type="IntervalTypeSpecifier">
                        <pointType localId="429" locator="188:32-188:39" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                     </asTypeSpecifier>
                  </source>
                  <condition localId="432" locator="188:43-188:46" valueType="t:Boolean" value="true" xsi:type="Literal"/>
                  <code localId="433" locator="188:49-188:51" valueType="t:String" value="1" xsi:type="Literal"/>
                  <severity localId="434" locator="188:54-188:60" valueType="t:String" value="Error" xsi:type="Literal"/>
                  <message localId="435" locator="188:63-188:110" valueType="t:String" value="Cannot compute an interval from a String value" xsi:type="Literal"/>
               </then>
            </caseItem>
            <else localId="441" locator="190:4-190:29" strict="false" xsi:type="As">
               <operand localId="438" locator="190:4-190:7" xsi:type="Null"/>
               <asTypeSpecifier localId="440" locator="190:12-190:29" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="439" locator="190:21-190:28" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </asTypeSpecifier>
            </else>
         </expression>
         <operand name="choice">
            <operandTypeSpecifier localId="316" locator="171:45-171:140" xsi:type="ChoiceTypeSpecifier">
               <choice localId="309" locator="171:52-171:64" name="fhir:dateTime" xsi:type="NamedTypeSpecifier"/>
               <choice localId="310" locator="171:67-171:77" name="fhir:Period" xsi:type="NamedTypeSpecifier"/>
               <choice localId="311" locator="171:80-171:90" name="fhir:Timing" xsi:type="NamedTypeSpecifier"/>
               <choice localId="312" locator="171:93-171:104" name="fhir:instant" xsi:type="NamedTypeSpecifier"/>
               <choice localId="313" locator="171:107-171:117" name="fhir:string" xsi:type="NamedTypeSpecifier"/>
               <choice localId="314" locator="171:120-171:127" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
               <choice localId="315" locator="171:130-171:139" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="563" locator="193:1-208:10" name="Normalize Abatement" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="563">
               <a:s>define function &quot;Normalize Abatement&quot;(condition </a:s>
               <a:s r="444">
                  <a:s>Condition</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="562">
                  <a:s r="562">
                     <a:s>if </a:s>
                     <a:s r="448">
                        <a:s r="446">
                           <a:s r="445">
                              <a:s>condition</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="446">
                              <a:s>abatement</a:s>
                           </a:s>
                        </a:s>
                        <a:s> is </a:s>
                        <a:s r="447">
                           <a:s>FHIR.dateTime</a:s>
                        </a:s>
                     </a:s>
                     <a:s> then&#xd;
	  </a:s>
                     <a:s r="461">
                        <a:s>Interval[</a:s>
                        <a:s r="454">
                           <a:s r="449">
                              <a:s>FHIRHelpers</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="454">
                              <a:s>ToDateTime(</a:s>
                              <a:s r="453">
                                 <a:s r="451">
                                    <a:s r="450">
                                       <a:s>condition</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="451">
                                       <a:s>abatement</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> as </a:s>
                                 <a:s r="452">
                                    <a:s>FHIR.dateTime</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="460">
                           <a:s r="455">
                              <a:s>FHIRHelpers</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="460">
                              <a:s>ToDateTime(</a:s>
                              <a:s r="459">
                                 <a:s r="457">
                                    <a:s r="456">
                                       <a:s>condition</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="457">
                                       <a:s>abatement</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> as </a:s>
                                 <a:s r="458">
                                    <a:s>FHIR.dateTime</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>]</a:s>
                     </a:s>
                     <a:s>&#xd;
	else </a:s>
                     <a:s r="561">
                        <a:s>if </a:s>
                        <a:s r="465">
                           <a:s r="463">
                              <a:s r="462">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="463">
                                 <a:s>abatement</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="464">
                              <a:s>FHIR.Period</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then&#xd;
	  </a:s>
                        <a:s r="471">
                           <a:s r="466">
                              <a:s>FHIRHelpers</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="471">
                              <a:s>ToInterval(</a:s>
                              <a:s r="470">
                                 <a:s r="468">
                                    <a:s r="467">
                                       <a:s>condition</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="468">
                                       <a:s>abatement</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> as </a:s>
                                 <a:s r="469">
                                    <a:s>FHIR.Period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
	else </a:s>
                        <a:s r="560">
                           <a:s>if </a:s>
                           <a:s r="475">
                              <a:s r="473">
                                 <a:s r="472">
                                    <a:s>condition</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="473">
                                    <a:s>abatement</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> is </a:s>
                              <a:s r="474">
                                 <a:s>FHIR.string</a:s>
                              </a:s>
                           </a:s>
                           <a:s> then&#xd;
    </a:s>
                           <a:s r="484">
                              <a:s>Message(</a:s>
                              <a:s r="479">
                                 <a:s r="476">null as </a:s>
                                 <a:s r="478">
                                    <a:s>Interval&lt;</a:s>
                                    <a:s r="477">
                                       <a:s>DateTime</a:s>
                                    </a:s>
                                    <a:s>></a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="480">, true, </a:s>
                              <a:s r="481">
                                 <a:s>'1'</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="482">
                                 <a:s>'Error'</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="483">
                                 <a:s>'Cannot compute an interval from a String value'</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s>&#xd;
	else </a:s>
                           <a:s r="559">
                              <a:s>if </a:s>
                              <a:s r="488">
                                 <a:s r="486">
                                    <a:s r="485">
                                       <a:s>condition</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="486">
                                       <a:s>abatement</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> is </a:s>
                                 <a:s r="487">
                                    <a:s>FHIR.Age</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> then&#xd;
		</a:s>
                              <a:s r="513">
                                 <a:s>Interval[</a:s>
                                 <a:s r="499">
                                    <a:s r="492">
                                       <a:s r="489">
                                          <a:s>FHIRHelpers</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="492">
                                          <a:s>ToDate(</a:s>
                                          <a:s r="491">
                                             <a:s r="490">
                                                <a:s>Patient</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="491">
                                                <a:s>birthDate</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>)</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> + </a:s>
                                    <a:s r="498">
                                       <a:s r="493">
                                          <a:s>FHIRHelpers</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="498">
                                          <a:s>ToQuantity(</a:s>
                                          <a:s r="497">
                                             <a:s r="495">
                                                <a:s r="494">
                                                   <a:s>condition</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="495">
                                                   <a:s>abatement</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s> as </a:s>
                                             <a:s r="496">
                                                <a:s>FHIR.Age</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>)</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>,&#xd;
			</a:s>
                                 <a:s r="512">
                                    <a:s r="510">
                                       <a:s r="503">
                                          <a:s r="500">
                                             <a:s>FHIRHelpers</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="503">
                                             <a:s>ToDate(</a:s>
                                             <a:s r="502">
                                                <a:s r="501">
                                                   <a:s>Patient</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="502">
                                                   <a:s>birthDate</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> + </a:s>
                                       <a:s r="509">
                                          <a:s r="504">
                                             <a:s>FHIRHelpers</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="509">
                                             <a:s>ToQuantity(</a:s>
                                             <a:s r="508">
                                                <a:s r="506">
                                                   <a:s r="505">
                                                      <a:s>condition</a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="506">
                                                      <a:s>abatement</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s> as </a:s>
                                                <a:s r="507">
                                                   <a:s>FHIR.Age</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> + </a:s>
                                    <a:s r="511">
                                       <a:s>1 year</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>&#xd;
	else </a:s>
                              <a:s r="558">
                                 <a:s>if </a:s>
                                 <a:s r="517">
                                    <a:s r="515">
                                       <a:s r="514">
                                          <a:s>condition</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="515">
                                          <a:s>abatement</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> is </a:s>
                                    <a:s r="516">
                                       <a:s>FHIR.Range</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> then&#xd;
	  </a:s>
                                 <a:s r="544">
                                    <a:s>Interval[</a:s>
                                    <a:s r="529">
                                       <a:s r="521">
                                          <a:s r="518">
                                             <a:s>FHIRHelpers</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="521">
                                             <a:s>ToDate(</a:s>
                                             <a:s r="520">
                                                <a:s r="519">
                                                   <a:s>Patient</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="520">
                                                   <a:s>birthDate</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> + </a:s>
                                       <a:s r="528">
                                          <a:s r="522">
                                             <a:s>FHIRHelpers</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="528">
                                             <a:s>ToQuantity(</a:s>
                                             <a:s r="527">
                                                <a:s r="526">
                                                   <a:s>(</a:s>
                                                   <a:s r="526">
                                                      <a:s r="524">
                                                         <a:s r="523">
                                                            <a:s>condition</a:s>
                                                         </a:s>
                                                         <a:s>.</a:s>
                                                         <a:s r="524">
                                                            <a:s>abatement</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> as </a:s>
                                                      <a:s r="525">
                                                         <a:s>FHIR.Range</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>)</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="527">
                                                   <a:s>low</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>,&#xd;
		  </a:s>
                                    <a:s r="543">
                                       <a:s r="541">
                                          <a:s r="533">
                                             <a:s r="530">
                                                <a:s>FHIRHelpers</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="533">
                                                <a:s>ToDate(</a:s>
                                                <a:s r="532">
                                                   <a:s r="531">
                                                      <a:s>Patient</a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="532">
                                                      <a:s>birthDate</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>)</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> + </a:s>
                                          <a:s r="540">
                                             <a:s r="534">
                                                <a:s>FHIRHelpers</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="540">
                                                <a:s>ToQuantity(</a:s>
                                                <a:s r="539">
                                                   <a:s r="538">
                                                      <a:s>(</a:s>
                                                      <a:s r="538">
                                                         <a:s r="536">
                                                            <a:s r="535">
                                                               <a:s>condition</a:s>
                                                            </a:s>
                                                            <a:s>.</a:s>
                                                            <a:s r="536">
                                                               <a:s>abatement</a:s>
                                                            </a:s>
                                                         </a:s>
                                                         <a:s> as </a:s>
                                                         <a:s r="537">
                                                            <a:s>FHIR.Range</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s>)</a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="539">
                                                      <a:s>high</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>)</a:s>
                                             </a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> + </a:s>
                                       <a:s r="542">
                                          <a:s>1 year</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                                 <a:s>&#xd;
	else </a:s>
                                 <a:s r="557">
                                    <a:s>if </a:s>
                                    <a:s r="548">
                                       <a:s r="546">
                                          <a:s r="545">
                                             <a:s>condition</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="546">
                                             <a:s>abatement</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> is </a:s>
                                       <a:s r="547">
                                          <a:s>FHIR.boolean</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> then&#xd;
	  </a:s>
                                    <a:s r="555">
                                       <a:s>Interval[</a:s>
                                       <a:s r="552">
                                          <a:s>end of </a:s>
                                          <a:s r="551">
                                             <a:s>&quot;Normalize Interval&quot;(</a:s>
                                             <a:s r="550">
                                                <a:s r="549">
                                                   <a:s>condition</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="550">
                                                   <a:s>onset</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>, </a:s>
                                       <a:s r="554">
                                          <a:s r="553">
                                             <a:s>condition</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="554">
                                             <a:s>recordedDate</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                    <a:s r="556">&#xd;
	else null</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="562" locator="194:2-208:10" xsi:type="If">
            <condition asType="t:Boolean" xsi:type="As">
               <operand localId="448" locator="194:5-194:40" xsi:type="Is">
                  <operand localId="446" locator="194:5-194:23" path="abatement" xsi:type="Property">
                     <source localId="445" locator="194:5-194:13" name="condition" xsi:type="OperandRef"/>
                  </operand>
                  <isTypeSpecifier localId="447" locator="194:28-194:40" name="fhir:dateTime" xsi:type="NamedTypeSpecifier"/>
               </operand>
            </condition>
            <then localId="461" locator="195:4-195:135" lowClosed="true" highClosed="true" xsi:type="Interval">
               <low localId="454" locator="195:13-195:72" name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="453" locator="195:36-195:71" strict="false" xsi:type="As">
                     <operand localId="451" locator="195:36-195:54" path="abatement" xsi:type="Property">
                        <source localId="450" locator="195:36-195:44" name="condition" xsi:type="OperandRef"/>
                     </operand>
                     <asTypeSpecifier localId="452" locator="195:59-195:71" name="fhir:dateTime" xsi:type="NamedTypeSpecifier"/>
                  </operand>
               </low>
               <high localId="460" locator="195:75-195:134" name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="459" locator="195:98-195:133" strict="false" xsi:type="As">
                     <operand localId="457" locator="195:98-195:116" path="abatement" xsi:type="Property">
                        <source localId="456" locator="195:98-195:106" name="condition" xsi:type="OperandRef"/>
                     </operand>
                     <asTypeSpecifier localId="458" locator="195:121-195:133" name="fhir:dateTime" xsi:type="NamedTypeSpecifier"/>
                  </operand>
               </high>
            </then>
            <else localId="561" locator="196:7-208:10" xsi:type="If">
               <condition asType="t:Boolean" xsi:type="As">
                  <operand localId="465" locator="196:10-196:43" xsi:type="Is">
                     <operand localId="463" locator="196:10-196:28" path="abatement" xsi:type="Property">
                        <source localId="462" locator="196:10-196:18" name="condition" xsi:type="OperandRef"/>
                     </operand>
                     <isTypeSpecifier localId="464" locator="196:33-196:43" name="fhir:Period" xsi:type="NamedTypeSpecifier"/>
                  </operand>
               </condition>
               <then localId="471" locator="197:4-197:61" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="470" locator="197:27-197:60" strict="false" xsi:type="As">
                     <operand localId="468" locator="197:27-197:45" path="abatement" xsi:type="Property">
                        <source localId="467" locator="197:27-197:35" name="condition" xsi:type="OperandRef"/>
                     </operand>
                     <asTypeSpecifier localId="469" locator="197:50-197:60" name="fhir:Period" xsi:type="NamedTypeSpecifier"/>
                  </operand>
               </then>
               <else localId="560" locator="198:7-208:10" xsi:type="If">
                  <condition asType="t:Boolean" xsi:type="As">
                     <operand localId="475" locator="198:10-198:43" xsi:type="Is">
                        <operand localId="473" locator="198:10-198:28" path="abatement" xsi:type="Property">
                           <source localId="472" locator="198:10-198:18" name="condition" xsi:type="OperandRef"/>
                        </operand>
                        <isTypeSpecifier localId="474" locator="198:33-198:43" name="fhir:string" xsi:type="NamedTypeSpecifier"/>
                     </operand>
                  </condition>
                  <then localId="484" locator="199:5-199:109" xsi:type="Message">
                     <source localId="479" locator="199:13-199:38" strict="false" xsi:type="As">
                        <operand localId="476" locator="199:13-199:16" xsi:type="Null"/>
                        <asTypeSpecifier localId="478" locator="199:21-199:38" xsi:type="IntervalTypeSpecifier">
                           <pointType localId="477" locator="199:30-199:37" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                        </asTypeSpecifier>
                     </source>
                     <condition localId="480" locator="199:41-199:44" valueType="t:Boolean" value="true" xsi:type="Literal"/>
                     <code localId="481" locator="199:47-199:49" valueType="t:String" value="1" xsi:type="Literal"/>
                     <severity localId="482" locator="199:52-199:58" valueType="t:String" value="Error" xsi:type="Literal"/>
                     <message localId="483" locator="199:61-199:108" valueType="t:String" value="Cannot compute an interval from a String value" xsi:type="Literal"/>
                  </then>
                  <else localId="559" locator="200:7-208:10" xsi:type="If">
                     <condition asType="t:Boolean" xsi:type="As">
                        <operand localId="488" locator="200:10-200:40" xsi:type="Is">
                           <operand localId="486" locator="200:10-200:28" path="abatement" xsi:type="Property">
                              <source localId="485" locator="200:10-200:18" name="condition" xsi:type="OperandRef"/>
                           </operand>
                           <isTypeSpecifier localId="487" locator="200:33-200:40" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                        </operand>
                     </condition>
                     <then xsi:type="Interval">
                        <low xsi:type="ToDateTime">
                           <operand path="low" xsi:type="Property">
                              <source localId="513" locator="201:3-202:108" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="499" locator="201:12-201:106" xsi:type="Add">
                                    <operand localId="492" locator="201:12-201:48" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="491" locator="201:31-201:47" path="birthDate" xsi:type="Property">
                                          <source localId="490" locator="201:31-201:37" name="Patient" xsi:type="ExpressionRef"/>
                                       </operand>
                                    </operand>
                                    <operand localId="498" locator="201:52-201:106" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="497" locator="201:75-201:105" strict="false" xsi:type="As">
                                          <operand localId="495" locator="201:75-201:93" path="abatement" xsi:type="Property">
                                             <source localId="494" locator="201:75-201:83" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                          <asTypeSpecifier localId="496" locator="201:98-201:105" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                 </low>
                                 <high localId="512" locator="202:4-202:107" xsi:type="Add">
                                    <operand localId="510" locator="202:4-202:98" xsi:type="Add">
                                       <operand localId="503" locator="202:4-202:40" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="502" locator="202:23-202:39" path="birthDate" xsi:type="Property">
                                             <source localId="501" locator="202:23-202:29" name="Patient" xsi:type="ExpressionRef"/>
                                          </operand>
                                       </operand>
                                       <operand localId="509" locator="202:44-202:98" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="508" locator="202:67-202:97" strict="false" xsi:type="As">
                                             <operand localId="506" locator="202:67-202:85" path="abatement" xsi:type="Property">
                                                <source localId="505" locator="202:67-202:75" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                             <asTypeSpecifier localId="507" locator="202:90-202:97" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                    </operand>
                                    <operand localId="511" locator="202:102-202:107" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </operand>
                        </low>
                        <lowClosedExpression path="lowClosed" xsi:type="Property">
                           <source localId="513" locator="201:3-202:108" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="499" locator="201:12-201:106" xsi:type="Add">
                                 <operand localId="492" locator="201:12-201:48" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="491" locator="201:31-201:47" path="birthDate" xsi:type="Property">
                                       <source localId="490" locator="201:31-201:37" name="Patient" xsi:type="ExpressionRef"/>
                                    </operand>
                                 </operand>
                                 <operand localId="498" locator="201:52-201:106" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="497" locator="201:75-201:105" strict="false" xsi:type="As">
                                       <operand localId="495" locator="201:75-201:93" path="abatement" xsi:type="Property">
                                          <source localId="494" locator="201:75-201:83" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                       <asTypeSpecifier localId="496" locator="201:98-201:105" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                              </low>
                              <high localId="512" locator="202:4-202:107" xsi:type="Add">
                                 <operand localId="510" locator="202:4-202:98" xsi:type="Add">
                                    <operand localId="503" locator="202:4-202:40" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="502" locator="202:23-202:39" path="birthDate" xsi:type="Property">
                                          <source localId="501" locator="202:23-202:29" name="Patient" xsi:type="ExpressionRef"/>
                                       </operand>
                                    </operand>
                                    <operand localId="509" locator="202:44-202:98" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="508" locator="202:67-202:97" strict="false" xsi:type="As">
                                          <operand localId="506" locator="202:67-202:85" path="abatement" xsi:type="Property">
                                             <source localId="505" locator="202:67-202:75" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                          <asTypeSpecifier localId="507" locator="202:90-202:97" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                 </operand>
                                 <operand localId="511" locator="202:102-202:107" value="1" unit="year" xsi:type="Quantity"/>
                              </high>
                           </source>
                        </lowClosedExpression>
                        <high xsi:type="ToDateTime">
                           <operand path="high" xsi:type="Property">
                              <source localId="513" locator="201:3-202:108" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="499" locator="201:12-201:106" xsi:type="Add">
                                    <operand localId="492" locator="201:12-201:48" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="491" locator="201:31-201:47" path="birthDate" xsi:type="Property">
                                          <source localId="490" locator="201:31-201:37" name="Patient" xsi:type="ExpressionRef"/>
                                       </operand>
                                    </operand>
                                    <operand localId="498" locator="201:52-201:106" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="497" locator="201:75-201:105" strict="false" xsi:type="As">
                                          <operand localId="495" locator="201:75-201:93" path="abatement" xsi:type="Property">
                                             <source localId="494" locator="201:75-201:83" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                          <asTypeSpecifier localId="496" locator="201:98-201:105" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                 </low>
                                 <high localId="512" locator="202:4-202:107" xsi:type="Add">
                                    <operand localId="510" locator="202:4-202:98" xsi:type="Add">
                                       <operand localId="503" locator="202:4-202:40" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="502" locator="202:23-202:39" path="birthDate" xsi:type="Property">
                                             <source localId="501" locator="202:23-202:29" name="Patient" xsi:type="ExpressionRef"/>
                                          </operand>
                                       </operand>
                                       <operand localId="509" locator="202:44-202:98" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="508" locator="202:67-202:97" strict="false" xsi:type="As">
                                             <operand localId="506" locator="202:67-202:85" path="abatement" xsi:type="Property">
                                                <source localId="505" locator="202:67-202:75" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                             <asTypeSpecifier localId="507" locator="202:90-202:97" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                    </operand>
                                    <operand localId="511" locator="202:102-202:107" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </operand>
                        </high>
                        <highClosedExpression path="highClosed" xsi:type="Property">
                           <source localId="513" locator="201:3-202:108" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="499" locator="201:12-201:106" xsi:type="Add">
                                 <operand localId="492" locator="201:12-201:48" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="491" locator="201:31-201:47" path="birthDate" xsi:type="Property">
                                       <source localId="490" locator="201:31-201:37" name="Patient" xsi:type="ExpressionRef"/>
                                    </operand>
                                 </operand>
                                 <operand localId="498" locator="201:52-201:106" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="497" locator="201:75-201:105" strict="false" xsi:type="As">
                                       <operand localId="495" locator="201:75-201:93" path="abatement" xsi:type="Property">
                                          <source localId="494" locator="201:75-201:83" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                       <asTypeSpecifier localId="496" locator="201:98-201:105" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                              </low>
                              <high localId="512" locator="202:4-202:107" xsi:type="Add">
                                 <operand localId="510" locator="202:4-202:98" xsi:type="Add">
                                    <operand localId="503" locator="202:4-202:40" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="502" locator="202:23-202:39" path="birthDate" xsi:type="Property">
                                          <source localId="501" locator="202:23-202:29" name="Patient" xsi:type="ExpressionRef"/>
                                       </operand>
                                    </operand>
                                    <operand localId="509" locator="202:44-202:98" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="508" locator="202:67-202:97" strict="false" xsi:type="As">
                                          <operand localId="506" locator="202:67-202:85" path="abatement" xsi:type="Property">
                                             <source localId="505" locator="202:67-202:75" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                          <asTypeSpecifier localId="507" locator="202:90-202:97" name="fhir:Age" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                 </operand>
                                 <operand localId="511" locator="202:102-202:107" value="1" unit="year" xsi:type="Quantity"/>
                              </high>
                           </source>
                        </highClosedExpression>
                     </then>
                     <else localId="558" locator="203:7-208:10" xsi:type="If">
                        <condition asType="t:Boolean" xsi:type="As">
                           <operand localId="517" locator="203:10-203:42" xsi:type="Is">
                              <operand localId="515" locator="203:10-203:28" path="abatement" xsi:type="Property">
                                 <source localId="514" locator="203:10-203:18" name="condition" xsi:type="OperandRef"/>
                              </operand>
                              <isTypeSpecifier localId="516" locator="203:33-203:42" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                           </operand>
                        </condition>
                        <then xsi:type="Interval">
                           <low xsi:type="ToDateTime">
                              <operand path="low" xsi:type="Property">
                                 <source localId="544" locator="204:4-205:118" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="529" locator="204:13-204:115" xsi:type="Add">
                                       <operand localId="521" locator="204:13-204:49" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="520" locator="204:32-204:48" path="birthDate" xsi:type="Property">
                                             <source localId="519" locator="204:32-204:38" name="Patient" xsi:type="ExpressionRef"/>
                                          </operand>
                                       </operand>
                                       <operand localId="528" locator="204:53-204:115" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="527" locator="204:76-204:114" path="low" xsi:type="Property">
                                             <source localId="526" locator="204:76-204:110" strict="false" xsi:type="As">
                                                <operand localId="524" locator="204:77-204:95" path="abatement" xsi:type="Property">
                                                   <source localId="523" locator="204:77-204:85" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                                <asTypeSpecifier localId="525" locator="204:100-204:109" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                             </source>
                                          </operand>
                                       </operand>
                                    </low>
                                    <high localId="543" locator="205:5-205:117" xsi:type="Add">
                                       <operand localId="541" locator="205:5-205:108" xsi:type="Add">
                                          <operand localId="533" locator="205:5-205:41" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="532" locator="205:24-205:40" path="birthDate" xsi:type="Property">
                                                <source localId="531" locator="205:24-205:30" name="Patient" xsi:type="ExpressionRef"/>
                                             </operand>
                                          </operand>
                                          <operand localId="540" locator="205:45-205:108" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="539" locator="205:68-205:107" path="high" xsi:type="Property">
                                                <source localId="538" locator="205:68-205:102" strict="false" xsi:type="As">
                                                   <operand localId="536" locator="205:69-205:87" path="abatement" xsi:type="Property">
                                                      <source localId="535" locator="205:69-205:77" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                   <asTypeSpecifier localId="537" locator="205:92-205:101" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                                </source>
                                             </operand>
                                          </operand>
                                       </operand>
                                       <operand localId="542" locator="205:112-205:117" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </operand>
                           </low>
                           <lowClosedExpression path="lowClosed" xsi:type="Property">
                              <source localId="544" locator="204:4-205:118" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="529" locator="204:13-204:115" xsi:type="Add">
                                    <operand localId="521" locator="204:13-204:49" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="520" locator="204:32-204:48" path="birthDate" xsi:type="Property">
                                          <source localId="519" locator="204:32-204:38" name="Patient" xsi:type="ExpressionRef"/>
                                       </operand>
                                    </operand>
                                    <operand localId="528" locator="204:53-204:115" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="527" locator="204:76-204:114" path="low" xsi:type="Property">
                                          <source localId="526" locator="204:76-204:110" strict="false" xsi:type="As">
                                             <operand localId="524" locator="204:77-204:95" path="abatement" xsi:type="Property">
                                                <source localId="523" locator="204:77-204:85" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                             <asTypeSpecifier localId="525" locator="204:100-204:109" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                          </source>
                                       </operand>
                                    </operand>
                                 </low>
                                 <high localId="543" locator="205:5-205:117" xsi:type="Add">
                                    <operand localId="541" locator="205:5-205:108" xsi:type="Add">
                                       <operand localId="533" locator="205:5-205:41" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="532" locator="205:24-205:40" path="birthDate" xsi:type="Property">
                                             <source localId="531" locator="205:24-205:30" name="Patient" xsi:type="ExpressionRef"/>
                                          </operand>
                                       </operand>
                                       <operand localId="540" locator="205:45-205:108" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="539" locator="205:68-205:107" path="high" xsi:type="Property">
                                             <source localId="538" locator="205:68-205:102" strict="false" xsi:type="As">
                                                <operand localId="536" locator="205:69-205:87" path="abatement" xsi:type="Property">
                                                   <source localId="535" locator="205:69-205:77" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                                <asTypeSpecifier localId="537" locator="205:92-205:101" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                             </source>
                                          </operand>
                                       </operand>
                                    </operand>
                                    <operand localId="542" locator="205:112-205:117" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </lowClosedExpression>
                           <high xsi:type="ToDateTime">
                              <operand path="high" xsi:type="Property">
                                 <source localId="544" locator="204:4-205:118" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="529" locator="204:13-204:115" xsi:type="Add">
                                       <operand localId="521" locator="204:13-204:49" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="520" locator="204:32-204:48" path="birthDate" xsi:type="Property">
                                             <source localId="519" locator="204:32-204:38" name="Patient" xsi:type="ExpressionRef"/>
                                          </operand>
                                       </operand>
                                       <operand localId="528" locator="204:53-204:115" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="527" locator="204:76-204:114" path="low" xsi:type="Property">
                                             <source localId="526" locator="204:76-204:110" strict="false" xsi:type="As">
                                                <operand localId="524" locator="204:77-204:95" path="abatement" xsi:type="Property">
                                                   <source localId="523" locator="204:77-204:85" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                                <asTypeSpecifier localId="525" locator="204:100-204:109" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                             </source>
                                          </operand>
                                       </operand>
                                    </low>
                                    <high localId="543" locator="205:5-205:117" xsi:type="Add">
                                       <operand localId="541" locator="205:5-205:108" xsi:type="Add">
                                          <operand localId="533" locator="205:5-205:41" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="532" locator="205:24-205:40" path="birthDate" xsi:type="Property">
                                                <source localId="531" locator="205:24-205:30" name="Patient" xsi:type="ExpressionRef"/>
                                             </operand>
                                          </operand>
                                          <operand localId="540" locator="205:45-205:108" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="539" locator="205:68-205:107" path="high" xsi:type="Property">
                                                <source localId="538" locator="205:68-205:102" strict="false" xsi:type="As">
                                                   <operand localId="536" locator="205:69-205:87" path="abatement" xsi:type="Property">
                                                      <source localId="535" locator="205:69-205:77" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                   <asTypeSpecifier localId="537" locator="205:92-205:101" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                                </source>
                                             </operand>
                                          </operand>
                                       </operand>
                                       <operand localId="542" locator="205:112-205:117" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </operand>
                           </high>
                           <highClosedExpression path="highClosed" xsi:type="Property">
                              <source localId="544" locator="204:4-205:118" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="529" locator="204:13-204:115" xsi:type="Add">
                                    <operand localId="521" locator="204:13-204:49" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="520" locator="204:32-204:48" path="birthDate" xsi:type="Property">
                                          <source localId="519" locator="204:32-204:38" name="Patient" xsi:type="ExpressionRef"/>
                                       </operand>
                                    </operand>
                                    <operand localId="528" locator="204:53-204:115" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="527" locator="204:76-204:114" path="low" xsi:type="Property">
                                          <source localId="526" locator="204:76-204:110" strict="false" xsi:type="As">
                                             <operand localId="524" locator="204:77-204:95" path="abatement" xsi:type="Property">
                                                <source localId="523" locator="204:77-204:85" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                             <asTypeSpecifier localId="525" locator="204:100-204:109" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                          </source>
                                       </operand>
                                    </operand>
                                 </low>
                                 <high localId="543" locator="205:5-205:117" xsi:type="Add">
                                    <operand localId="541" locator="205:5-205:108" xsi:type="Add">
                                       <operand localId="533" locator="205:5-205:41" name="ToDate" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="532" locator="205:24-205:40" path="birthDate" xsi:type="Property">
                                             <source localId="531" locator="205:24-205:30" name="Patient" xsi:type="ExpressionRef"/>
                                          </operand>
                                       </operand>
                                       <operand localId="540" locator="205:45-205:108" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="539" locator="205:68-205:107" path="high" xsi:type="Property">
                                             <source localId="538" locator="205:68-205:102" strict="false" xsi:type="As">
                                                <operand localId="536" locator="205:69-205:87" path="abatement" xsi:type="Property">
                                                   <source localId="535" locator="205:69-205:77" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                                <asTypeSpecifier localId="537" locator="205:92-205:101" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
                                             </source>
                                          </operand>
                                       </operand>
                                    </operand>
                                    <operand localId="542" locator="205:112-205:117" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </highClosedExpression>
                        </then>
                        <else localId="557" locator="206:7-208:10" xsi:type="If">
                           <condition asType="t:Boolean" xsi:type="As">
                              <operand localId="548" locator="206:10-206:44" xsi:type="Is">
                                 <operand localId="546" locator="206:10-206:28" path="abatement" xsi:type="Property">
                                    <source localId="545" locator="206:10-206:18" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                                 <isTypeSpecifier localId="547" locator="206:33-206:44" name="fhir:boolean" xsi:type="NamedTypeSpecifier"/>
                              </operand>
                           </condition>
                           <then localId="555" locator="207:4-207:81" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="552" locator="207:13-207:56" xsi:type="End">
                                 <operand localId="551" locator="207:20-207:56" name="Normalize Interval" xsi:type="FunctionRef">
                                    <operand localId="550" locator="207:41-207:55" path="onset" xsi:type="Property">
                                       <source localId="549" locator="207:41-207:49" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </operand>
                              </low>
                              <high name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="554" locator="207:59-207:80" path="recordedDate" xsi:type="Property">
                                    <source localId="553" locator="207:59-207:67" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </high>
                           </then>
                           <else xsi:type="As">
                              <operand localId="556" locator="208:7-208:10" xsi:type="Null"/>
                              <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                                 <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </asTypeSpecifier>
                           </else>
                        </else>
                     </else>
                  </else>
               </else>
            </else>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="444" locator="193:49-193:57" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="573" locator="210:1-211:99" name="Prevalence Period" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="573">
               <a:s>define function &quot;Prevalence Period&quot;(condition </a:s>
               <a:s r="564">
                  <a:s>Condition</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="572">
                  <a:s r="572">
                     <a:s>Interval[</a:s>
                     <a:s r="568">
                        <a:s>start of </a:s>
                        <a:s r="567">
                           <a:s>&quot;Normalize Interval&quot;(</a:s>
                           <a:s r="566">
                              <a:s r="565">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="566">
                                 <a:s>onset</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>, </a:s>
                     <a:s r="571">
                        <a:s>end of </a:s>
                        <a:s r="570">
                           <a:s>&quot;Normalize Abatement&quot;(</a:s>
                           <a:s r="569">
                              <a:s>condition</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="572" locator="211:3-211:99" lowClosed="true" highClosed="false" xsi:type="Interval">
            <low localId="568" locator="211:12-211:57" xsi:type="Start">
               <operand localId="567" locator="211:21-211:57" name="Normalize Interval" xsi:type="FunctionRef">
                  <operand localId="566" locator="211:42-211:56" path="onset" xsi:type="Property">
                     <source localId="565" locator="211:42-211:50" name="condition" xsi:type="OperandRef"/>
                  </operand>
               </operand>
            </low>
            <high localId="571" locator="211:60-211:98" xsi:type="End">
               <operand localId="570" locator="211:67-211:98" name="Normalize Abatement" xsi:type="FunctionRef">
                  <operand localId="569" locator="211:89-211:97" name="condition" xsi:type="OperandRef"/>
               </operand>
            </high>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="564" locator="210:47-210:55" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="579" locator="213:1-214:22" name="GetId" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="579">
               <a:s>define function &quot;GetId&quot;(uri </a:s>
               <a:s r="574">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="578">
                  <a:s r="578">
                     <a:s>Last(</a:s>
                     <a:s r="577">
                        <a:s>Split(</a:s>
                        <a:s r="575">
                           <a:s>uri</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="576">
                           <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="578" locator="214:2-214:22" xsi:type="Last">
            <source localId="577" locator="214:7-214:21" xsi:type="Split">
               <stringToSplit localId="575" locator="214:13-214:15" name="uri" xsi:type="OperandRef"/>
               <separator localId="576" locator="214:18-214:20" valueType="t:String" value="/" xsi:type="Literal"/>
            </source>
         </expression>
         <operand name="uri">
            <operandTypeSpecifier localId="574" locator="213:29-213:34" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="596" locator="217:1-219:85" name="EncounterDiagnosis" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="596">
               <a:s>define function &quot;EncounterDiagnosis&quot;(Encounter </a:s>
               <a:s r="580">
                  <a:s>Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="595">
                  <a:s r="595">
                     <a:s>
                        <a:s r="582">
                           <a:s r="581">
                              <a:s>
                                 <a:s>Encounter.diagnosis</a:s>
                              </a:s>
                           </a:s>
                           <a:s> D</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
    </a:s>
                     <a:s r="594">
                        <a:s>return </a:s>
                        <a:s r="593">
                           <a:s>singleton from </a:s>
                           <a:s r="592">
                              <a:s>(</a:s>
                              <a:s r="592">
                                 <a:s>
                                    <a:s r="584">
                                       <a:s r="583">
                                          <a:s r="583">
                                             <a:s>[Condition]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> C</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> </a:s>
                                 <a:s r="591">
                                    <a:s>where </a:s>
                                    <a:s r="591">
                                       <a:s r="586">
                                          <a:s r="585">
                                             <a:s>C</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="586">
                                             <a:s>id</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> = </a:s>
                                       <a:s r="590">
                                          <a:s>&quot;GetId&quot;(</a:s>
                                          <a:s r="589">
                                             <a:s r="588">
                                                <a:s r="587">
                                                   <a:s>D</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="588">
                                                   <a:s>condition</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="589">
                                                <a:s>reference</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="595" locator="218:3-219:85" xsi:type="Query">
            <source localId="582" locator="218:3-218:23" alias="D">
               <expression localId="581" locator="218:3-218:21" path="diagnosis" xsi:type="Property">
                  <source name="Encounter" xsi:type="OperandRef"/>
               </expression>
            </source>
            <return localId="594" locator="219:5-219:85">
               <expression localId="593" locator="219:12-219:85" xsi:type="SingletonFrom">
                  <operand localId="592" locator="219:27-219:85" xsi:type="Query">
                     <source localId="584" locator="219:28-219:40" alias="C">
                        <expression localId="583" locator="219:28-219:38" dataType="fhir:Condition" templateId="http://hl7.org/fhir/StructureDefinition/Condition" xsi:type="Retrieve"/>
                     </source>
                     <where localId="591" locator="219:42-219:84" xsi:type="Equal">
                        <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="586" locator="219:48-219:51" path="id" scope="C" xsi:type="Property"/>
                        </operand>
                        <operand localId="590" locator="219:55-219:84" name="GetId" xsi:type="FunctionRef">
                           <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="589" locator="219:63-219:83" path="reference" xsi:type="Property">
                                 <source localId="588" locator="219:63-219:73" path="condition" scope="D" xsi:type="Property"/>
                              </operand>
                           </operand>
                        </operand>
                     </where>
                  </operand>
               </expression>
            </return>
         </expression>
         <operand name="Encounter">
            <operandTypeSpecifier localId="580" locator="217:48-217:56" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="622" locator="223:1-225:84" name="PrincipalDiagnosis" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="622">
               <a:s>define function &quot;PrincipalDiagnosis&quot;(Encounter </a:s>
               <a:s r="597">
                  <a:s>Encounter</a:s>
               </a:s>
               <a:s>):&#xd;
	</a:s>
               <a:s r="621">
                  <a:s r="621">
                     <a:s>
                        <a:s r="608">
                           <a:s r="607">
                              <a:s>(</a:s>
                              <a:s r="607">
                                 <a:s>singleton from </a:s>
                                 <a:s r="606">
                                    <a:s>(</a:s>
                                    <a:s r="606">
                                       <a:s>
                                          <a:s r="599">
                                             <a:s r="598">
                                                <a:s>
                                                   <a:s>Encounter.diagnosis</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s> D</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> </a:s>
                                       <a:s r="605">
                                          <a:s>where </a:s>
                                          <a:s r="605">
                                             <a:s r="603">
                                                <a:s r="600">
                                                   <a:s>FHIRHelpers</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="603">
                                                   <a:s>ToInteger(</a:s>
                                                   <a:s r="602">
                                                      <a:s r="601">
                                                         <a:s>D</a:s>
                                                      </a:s>
                                                      <a:s>.</a:s>
                                                      <a:s r="602">
                                                         <a:s>rank</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>)</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s r="604"> = 1</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s> PD</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="620">
                        <a:s>return </a:s>
                        <a:s r="619">
                           <a:s>singleton from </a:s>
                           <a:s r="618">
                              <a:s>(</a:s>
                              <a:s r="618">
                                 <a:s>
                                    <a:s r="610">
                                       <a:s r="609">
                                          <a:s r="609">
                                             <a:s>[Condition]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> C</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> </a:s>
                                 <a:s r="617">
                                    <a:s>where </a:s>
                                    <a:s r="617">
                                       <a:s r="612">
                                          <a:s r="611">
                                             <a:s>C</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="612">
                                             <a:s>id</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> = </a:s>
                                       <a:s r="616">
                                          <a:s>&quot;GetId&quot;(</a:s>
                                          <a:s r="615">
                                             <a:s r="614">
                                                <a:s r="613">
                                                   <a:s>PD</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="614">
                                                   <a:s>condition</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="615">
                                                <a:s>reference</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="621" locator="224:2-225:84" xsi:type="Query">
            <source localId="608" locator="224:2-224:84" alias="PD">
               <expression localId="607" locator="224:2-224:81" xsi:type="SingletonFrom">
                  <operand localId="606" locator="224:18-224:80" xsi:type="Query">
                     <source localId="599" locator="224:19-224:39" alias="D">
                        <expression localId="598" locator="224:19-224:37" path="diagnosis" xsi:type="Property">
                           <source name="Encounter" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <where localId="605" locator="224:41-224:79" xsi:type="Equal">
                        <operand localId="603" locator="224:47-224:75" name="ToInteger" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="602" locator="224:69-224:74" path="rank" scope="D" xsi:type="Property"/>
                        </operand>
                        <operand localId="604" locator="224:79" valueType="t:Integer" value="1" xsi:type="Literal"/>
                     </where>
                  </operand>
               </expression>
            </source>
            <return localId="620" locator="225:3-225:84">
               <expression localId="619" locator="225:10-225:84" xsi:type="SingletonFrom">
                  <operand localId="618" locator="225:25-225:84" xsi:type="Query">
                     <source localId="610" locator="225:26-225:38" alias="C">
                        <expression localId="609" locator="225:26-225:36" dataType="fhir:Condition" templateId="http://hl7.org/fhir/StructureDefinition/Condition" xsi:type="Retrieve"/>
                     </source>
                     <where localId="617" locator="225:40-225:83" xsi:type="Equal">
                        <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="612" locator="225:46-225:49" path="id" scope="C" xsi:type="Property"/>
                        </operand>
                        <operand localId="616" locator="225:53-225:83" name="GetId" xsi:type="FunctionRef">
                           <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="615" locator="225:61-225:82" path="reference" xsi:type="Property">
                                 <source localId="614" locator="225:61-225:72" path="condition" scope="PD" xsi:type="Property"/>
                              </operand>
                           </operand>
                        </operand>
                     </where>
                  </operand>
               </expression>
            </return>
         </expression>
         <operand name="Encounter">
            <operandTypeSpecifier localId="597" locator="223:48-223:56" name="fhir:Encounter" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="634" locator="228:1-231:3" name="GetLocation" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="634">
               <a:s>define function GetLocation(reference </a:s>
               <a:s r="623">
                  <a:s>Reference</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="633">
                  <a:s r="633">
                     <a:s>singleton from </a:s>
                     <a:s r="632">
                        <a:s>(&#xd;
    </a:s>
                        <a:s r="632">
                           <a:s>
                              <a:s r="625">
                                 <a:s r="624">
                                    <a:s r="624">
                                       <a:s>[Location]</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> L</a:s>
                              </a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="631">
                              <a:s>where </a:s>
                              <a:s r="631">
                                 <a:s r="627">
                                    <a:s r="626">
                                       <a:s>L</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="627">
                                       <a:s>id</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> = </a:s>
                                 <a:s r="630">
                                    <a:s>GetId(</a:s>
                                    <a:s r="629">
                                       <a:s r="628">
                                          <a:s>reference</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="629">
                                          <a:s>reference</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="633" locator="229:3-231:3" xsi:type="SingletonFrom">
            <operand localId="632" locator="229:18-231:3" xsi:type="Query">
               <source localId="625" locator="230:5-230:16" alias="L">
                  <expression localId="624" locator="230:5-230:14" dataType="fhir:Location" templateId="http://hl7.org/fhir/StructureDefinition/Location" xsi:type="Retrieve"/>
               </source>
               <where localId="631" locator="230:18-230:56" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="627" locator="230:24-230:27" path="id" scope="L" xsi:type="Property"/>
                  </operand>
                  <operand localId="630" locator="230:31-230:56" name="GetId" xsi:type="FunctionRef">
                     <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="629" locator="230:37-230:55" path="reference" xsi:type="Property">
                           <source localId="628" locator="230:37-230:45" name="reference" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="reference">
            <operandTypeSpecifier localId="623" locator="228:39-228:47" name="fhir:Reference" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="648" locator="238:1-241:10" name="GetExtensions" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="648">
               <a:s>define function &quot;GetExtensions&quot;(domainResource </a:s>
               <a:s r="635">
                  <a:s>DomainResource</a:s>
               </a:s>
               <a:s>, url </a:s>
               <a:s r="636">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="647">
                  <a:s r="647">
                     <a:s>
                        <a:s r="638">
                           <a:s r="637">
                              <a:s>
                                 <a:s>domainResource.extension</a:s>
                              </a:s>
                           </a:s>
                           <a:s> E</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
	  </a:s>
                     <a:s r="644">
                        <a:s>where </a:s>
                        <a:s r="644">
                           <a:s r="640">
                              <a:s r="639">
                                 <a:s>E</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="640">
                                 <a:s>url</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="643">
                              <a:s>(</a:s>
                              <a:s r="643">
                                 <a:s r="641">
                                    <a:s>'http://hl7.org/fhir/us/qicore/StructureDefinition/'</a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="642">
                                    <a:s>url</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="646">
                        <a:s>return </a:s>
                        <a:s r="645">
                           <a:s>E</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="647" locator="239:3-241:10" xsi:type="Query">
            <source localId="638" locator="239:3-239:28" alias="E">
               <expression localId="637" locator="239:3-239:26" path="extension" xsi:type="Property">
                  <source name="domainResource" xsi:type="OperandRef"/>
               </expression>
            </source>
            <where localId="644" locator="240:4-240:77" xsi:type="Equal">
               <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="640" locator="240:10-240:14" path="url" scope="E" xsi:type="Property"/>
               </operand>
               <operand localId="643" locator="240:18-240:77" xsi:type="Concatenate">
                  <operand localId="641" locator="240:19-240:70" valueType="t:String" value="http://hl7.org/fhir/us/qicore/StructureDefinition/" xsi:type="Literal"/>
                  <operand localId="642" locator="240:74-240:76" name="url" xsi:type="OperandRef"/>
               </operand>
            </where>
            <return localId="646" locator="241:3-241:10">
               <expression localId="645" locator="241:10" name="E" xsi:type="AliasRef"/>
            </return>
         </expression>
         <operand name="domainResource">
            <operandTypeSpecifier localId="635" locator="238:48-238:61" name="fhir:DomainResource" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="url">
            <operandTypeSpecifier localId="636" locator="238:68-238:73" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="655" locator="243:1-244:53" name="GetExtension" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="655">
               <a:s>define function &quot;GetExtension&quot;(domainResource </a:s>
               <a:s r="649">
                  <a:s>DomainResource</a:s>
               </a:s>
               <a:s>, url </a:s>
               <a:s r="650">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="654">
                  <a:s r="654">
                     <a:s>singleton from </a:s>
                     <a:s r="653">
                        <a:s>&quot;GetExtensions&quot;(</a:s>
                        <a:s r="651">
                           <a:s>domainResource</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="652">
                           <a:s>url</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="654" locator="244:3-244:53" xsi:type="SingletonFrom">
            <operand localId="653" locator="244:18-244:53" name="GetExtensions" xsi:type="FunctionRef">
               <operand localId="651" locator="244:34-244:47" name="domainResource" xsi:type="OperandRef"/>
               <operand localId="652" locator="244:50-244:52" name="url" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="domainResource">
            <operandTypeSpecifier localId="649" locator="243:47-243:60" name="fhir:DomainResource" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="url">
            <operandTypeSpecifier localId="650" locator="243:67-243:72" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="667" locator="251:1-254:10" name="GetExtensions" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="667">
               <a:s>define function &quot;GetExtensions&quot;(element </a:s>
               <a:s r="656">
                  <a:s>Element</a:s>
               </a:s>
               <a:s>, url </a:s>
               <a:s r="657">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="666">
                  <a:s r="666">
                     <a:s>
                        <a:s r="659">
                           <a:s r="658">
                              <a:s>
                                 <a:s>element.extension</a:s>
                              </a:s>
                           </a:s>
                           <a:s> E</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
	  </a:s>
                     <a:s r="663">
                        <a:s>where </a:s>
                        <a:s r="663">
                           <a:s r="661">
                              <a:s r="660">
                                 <a:s>E</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="661">
                                 <a:s>url</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="662">
                              <a:s>(</a:s>
                              <a:s r="662">
                                 <a:s>url</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="665">
                        <a:s>return </a:s>
                        <a:s r="664">
                           <a:s>E</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="666" locator="252:3-254:10" xsi:type="Query">
            <source localId="659" locator="252:3-252:21" alias="E">
               <expression localId="658" locator="252:3-252:19" path="extension" xsi:type="Property">
                  <source name="element" xsi:type="OperandRef"/>
               </expression>
            </source>
            <where localId="663" locator="253:4-253:22" xsi:type="Equal">
               <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="661" locator="253:10-253:14" path="url" scope="E" xsi:type="Property"/>
               </operand>
               <operand localId="662" locator="253:18-253:22" name="url" xsi:type="OperandRef"/>
            </where>
            <return localId="665" locator="254:3-254:10">
               <expression localId="664" locator="254:10" name="E" xsi:type="AliasRef"/>
            </return>
         </expression>
         <operand name="element">
            <operandTypeSpecifier localId="656" locator="251:41-251:47" name="fhir:Element" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="url">
            <operandTypeSpecifier localId="657" locator="251:54-251:59" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="674" locator="256:1-257:46" name="GetExtension" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="674">
               <a:s>define function &quot;GetExtension&quot;(element </a:s>
               <a:s r="668">
                  <a:s>Element</a:s>
               </a:s>
               <a:s>, url </a:s>
               <a:s r="669">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="673">
                  <a:s r="673">
                     <a:s>singleton from </a:s>
                     <a:s r="672">
                        <a:s>&quot;GetExtensions&quot;(</a:s>
                        <a:s r="670">
                           <a:s>element</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="671">
                           <a:s>url</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="673" locator="257:3-257:46" xsi:type="SingletonFrom">
            <operand localId="672" locator="257:18-257:46" name="GetExtensions" xsi:type="FunctionRef">
               <operand localId="670" locator="257:34-257:40" name="element" xsi:type="OperandRef"/>
               <operand localId="671" locator="257:43-257:45" name="url" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="element">
            <operandTypeSpecifier localId="668" locator="256:40-256:46" name="fhir:Element" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="url">
            <operandTypeSpecifier localId="669" locator="256:53-256:58" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="688" locator="264:1-267:10" name="GetBaseExtensions" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="688">
               <a:s>define function &quot;GetBaseExtensions&quot;(domainResource </a:s>
               <a:s r="675">
                  <a:s>DomainResource</a:s>
               </a:s>
               <a:s>, url </a:s>
               <a:s r="676">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="687">
                  <a:s r="687">
                     <a:s>
                        <a:s r="678">
                           <a:s r="677">
                              <a:s>
                                 <a:s>domainResource.extension</a:s>
                              </a:s>
                           </a:s>
                           <a:s> E</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
	  </a:s>
                     <a:s r="684">
                        <a:s>where </a:s>
                        <a:s r="684">
                           <a:s r="680">
                              <a:s r="679">
                                 <a:s>E</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="680">
                                 <a:s>url</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="683">
                              <a:s>(</a:s>
                              <a:s r="683">
                                 <a:s r="681">
                                    <a:s>'http://hl7.org/fhir/StructureDefinition/'</a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="682">
                                    <a:s>url</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
		</a:s>
                     <a:s r="686">
                        <a:s>return </a:s>
                        <a:s r="685">
                           <a:s>E</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="687" locator="265:3-267:10" xsi:type="Query">
            <source localId="678" locator="265:3-265:28" alias="E">
               <expression localId="677" locator="265:3-265:26" path="extension" xsi:type="Property">
                  <source name="domainResource" xsi:type="OperandRef"/>
               </expression>
            </source>
            <where localId="684" locator="266:4-266:67" xsi:type="Equal">
               <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="680" locator="266:10-266:14" path="url" scope="E" xsi:type="Property"/>
               </operand>
               <operand localId="683" locator="266:18-266:67" xsi:type="Concatenate">
                  <operand localId="681" locator="266:19-266:60" valueType="t:String" value="http://hl7.org/fhir/StructureDefinition/" xsi:type="Literal"/>
                  <operand localId="682" locator="266:64-266:66" name="url" xsi:type="OperandRef"/>
               </operand>
            </where>
            <return localId="686" locator="267:3-267:10">
               <expression localId="685" locator="267:10" name="E" xsi:type="AliasRef"/>
            </return>
         </expression>
         <operand name="domainResource">
            <operandTypeSpecifier localId="675" locator="264:52-264:65" name="fhir:DomainResource" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="url">
            <operandTypeSpecifier localId="676" locator="264:72-264:77" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="695" locator="269:1-270:57" name="GetBaseExtension" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="695">
               <a:s>define function &quot;GetBaseExtension&quot;(domainResource </a:s>
               <a:s r="689">
                  <a:s>DomainResource</a:s>
               </a:s>
               <a:s>, url </a:s>
               <a:s r="690">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="694">
                  <a:s r="694">
                     <a:s>singleton from </a:s>
                     <a:s r="693">
                        <a:s>&quot;GetBaseExtensions&quot;(</a:s>
                        <a:s r="691">
                           <a:s>domainResource</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="692">
                           <a:s>url</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="694" locator="270:3-270:57" xsi:type="SingletonFrom">
            <operand localId="693" locator="270:18-270:57" name="GetBaseExtensions" xsi:type="FunctionRef">
               <operand localId="691" locator="270:38-270:51" name="domainResource" xsi:type="OperandRef"/>
               <operand localId="692" locator="270:54-270:56" name="url" xsi:type="OperandRef"/>
            </operand>
         </expression>
         <operand name="domainResource">
            <operandTypeSpecifier localId="689" locator="269:51-269:64" name="fhir:DomainResource" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="url">
            <operandTypeSpecifier localId="690" locator="269:71-269:76" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="699" locator="276:1-277:54" name="GetProvenance" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="699">
               <a:s>define function &quot;GetProvenance&quot;(resource </a:s>
               <a:s r="696">
                  <a:s>Resource</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="698">
                  <a:s r="698">
                     <a:s>singleton from </a:s>
                     <a:s r="697">
                        <a:s>(</a:s>
                        <a:s r="697">
                           <a:s>[Provenance: </a:s>
                           <a:s>
                              <a:s>target</a:s>
                           </a:s>
                           <a:s> in </a:s>
                           <a:s>
                              <a:s>resource.id</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="698" locator="277:3-277:54" xsi:type="SingletonFrom">
            <operand localId="697" locator="277:18-277:54" dataType="fhir:Provenance" templateId="http://hl7.org/fhir/StructureDefinition/Provenance" codeProperty="target" xsi:type="Retrieve">
               <codes xsi:type="ToList">
                  <operand locator="277:42-277:52" path="id" xsi:type="Property">
                     <source name="resource" xsi:type="OperandRef"/>
                  </operand>
               </codes>
            </operand>
         </expression>
         <operand name="resource">
            <operandTypeSpecifier localId="696" locator="276:42-276:49" name="fhir:Resource" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="724" locator="279:1-283:105" name="GetMedicationCode" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="724">
               <a:s>define function &quot;GetMedicationCode&quot;(request </a:s>
               <a:s r="700">
                  <a:s>MedicationRequest</a:s>
               </a:s>
               <a:s>):&#xd;
  </a:s>
               <a:s r="723">
                  <a:s r="723">
                     <a:s>if </a:s>
                     <a:s r="704">
                        <a:s r="702">
                           <a:s r="701">
                              <a:s>request</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="702">
                              <a:s>medication</a:s>
                           </a:s>
                        </a:s>
                        <a:s> is </a:s>
                        <a:s r="703">
                           <a:s>CodeableConcept</a:s>
                        </a:s>
                     </a:s>
                     <a:s> then&#xd;
	  </a:s>
                     <a:s r="708">
                        <a:s r="706">
                           <a:s r="705">
                              <a:s>request</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="706">
                              <a:s>medication</a:s>
                           </a:s>
                        </a:s>
                        <a:s> as </a:s>
                        <a:s r="707">
                           <a:s>CodeableConcept</a:s>
                        </a:s>
                     </a:s>
                     <a:s>&#xd;
	else&#xd;
	  </a:s>
                     <a:s r="722">
                        <a:s r="721">
                           <a:s>(</a:s>
                           <a:s r="721">
                              <a:s>singleton from </a:s>
                              <a:s r="720">
                                 <a:s>(</a:s>
                                 <a:s r="720">
                                    <a:s>
                                       <a:s r="710">
                                          <a:s r="709">
                                             <a:s r="709">
                                                <a:s>[Medication]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> M</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> </a:s>
                                    <a:s r="719">
                                       <a:s>where </a:s>
                                       <a:s r="719">
                                          <a:s r="712">
                                             <a:s r="711">
                                                <a:s>M</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="712">
                                                <a:s>id</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> = </a:s>
                                          <a:s r="718">
                                             <a:s>GetId(</a:s>
                                             <a:s r="717">
                                                <a:s r="716">
                                                   <a:s>(</a:s>
                                                   <a:s r="716">
                                                      <a:s r="714">
                                                         <a:s r="713">
                                                            <a:s>request</a:s>
                                                         </a:s>
                                                         <a:s>.</a:s>
                                                         <a:s r="714">
                                                            <a:s>medication</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> as </a:s>
                                                      <a:s r="715">
                                                         <a:s>Reference</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>)</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="717">
                                                   <a:s>reference</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 r="722">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="723" locator="280:3-283:105" xsi:type="If">
            <condition asType="t:Boolean" xsi:type="As">
               <operand localId="704" locator="280:6-280:42" xsi:type="Is">
                  <operand localId="702" locator="280:6-280:23" path="medication" xsi:type="Property">
                     <source localId="701" locator="280:6-280:12" name="request" xsi:type="OperandRef"/>
                  </operand>
                  <isTypeSpecifier localId="703" locator="280:28-280:42" name="fhir:CodeableConcept" xsi:type="NamedTypeSpecifier"/>
               </operand>
            </condition>
            <then localId="708" locator="281:4-281:40" strict="false" xsi:type="As">
               <operand localId="706" locator="281:4-281:21" path="medication" xsi:type="Property">
                  <source localId="705" locator="281:4-281:10" name="request" xsi:type="OperandRef"/>
               </operand>
               <asTypeSpecifier localId="707" locator="281:26-281:40" name="fhir:CodeableConcept" xsi:type="NamedTypeSpecifier"/>
            </then>
            <else localId="722" locator="283:4-283:105" path="code" xsi:type="Property">
               <source localId="721" locator="283:4-283:100" xsi:type="SingletonFrom">
                  <operand localId="720" locator="283:20-283:99" xsi:type="Query">
                     <source localId="710" locator="283:21-283:34" alias="M">
                        <expression localId="709" locator="283:21-283:32" dataType="fhir:Medication" templateId="http://hl7.org/fhir/StructureDefinition/Medication" xsi:type="Retrieve"/>
                     </source>
                     <where localId="719" locator="283:36-283:98" xsi:type="Equal">
                        <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="712" locator="283:42-283:45" path="id" scope="M" xsi:type="Property"/>
                        </operand>
                        <operand localId="718" locator="283:49-283:98" name="GetId" xsi:type="FunctionRef">
                           <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="717" locator="283:55-283:97" path="reference" xsi:type="Property">
                                 <source localId="716" locator="283:55-283:87" strict="false" xsi:type="As">
                                    <operand localId="714" locator="283:56-283:73" path="medication" xsi:type="Property">
                                       <source localId="713" locator="283:56-283:62" name="request" xsi:type="OperandRef"/>
                                    </operand>
                                    <asTypeSpecifier localId="715" locator="283:78-283:86" name="fhir:Reference" xsi:type="NamedTypeSpecifier"/>
                                 </source>
                              </operand>
                           </operand>
                        </operand>
                     </where>
                  </operand>
               </source>
            </else>
         </expression>
         <operand name="request">
            <operandTypeSpecifier localId="700" locator="279:45-279:61" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      }, {
         "librarySystem" : "http://fhir.org/guides/dbcg/connectathon",
         "libraryId" : "MATGlobalCommonFunctions",
         "libraryVersion" : "5.0.000",
         "startLine" : 277,
         "startChar" : 19,
         "endLine" : 277,
         "endChar" : 53,
         "message" : "Could not resolve membership operator for terminology target of the retrieve.",
         "errorType" : "semantic",
         "errorSeverity" : "warning",
         "type" : "CqlToElmError"
      } ],
      "identifier" : {
         "id" : "MATGlobalCommonFunctions",
         "system" : "http://fhir.org/guides/dbcg/connectathon",
         "version" : "5.0.000"
      },
      "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:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1"
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "2",
            "locator" : "5:1-5:54",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/dbcg/connectathon/FHIRHelpers",
            "version" : "4.0.1"
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "71",
            "locator" : "57:1-58:66",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "default" : {
               "localId" : "68",
               "locator" : "58:11-58:66",
               "lowClosed" : true,
               "highClosed" : false,
               "type" : "Interval",
               "low" : {
                  "localId" : "66",
                  "locator" : "58:20-58:41",
                  "type" : "DateTime",
                  "year" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2019",
                     "type" : "Literal"
                  },
                  "month" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "day" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "hour" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "minute" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "second" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "millisecond" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               },
               "high" : {
                  "localId" : "67",
                  "locator" : "58:44-58:65",
                  "type" : "DateTime",
                  "year" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2020",
                     "type" : "Literal"
                  },
                  "month" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "day" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "hour" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "minute" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "second" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "millisecond" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               }
            },
            "parameterTypeSpecifier" : {
               "localId" : "70",
               "locator" : "57:32-57:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "69",
                  "locator" : "57:41-57:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "3",
            "locator" : "7:1-7:38",
            "name" : "LOINC",
            "id" : "http://loinc.org",
            "accessLevel" : "Public"
         }, {
            "localId" : "4",
            "locator" : "8:1-8:60",
            "name" : "SNOMEDCT",
            "id" : "http://snomed.info/sct/731000124108",
            "accessLevel" : "Public"
         }, {
            "localId" : "5",
            "locator" : "9:1-9:56",
            "name" : "RoleCode",
            "id" : "http://hl7.org/fhir/v3/RoleCode",
            "accessLevel" : "Public"
         }, {
            "localId" : "6",
            "locator" : "10:1-10:83",
            "name" : "Diagnosis Role",
            "id" : "http://terminology.hl7.org/CodeSystem/diagnosis-role",
            "accessLevel" : "Public"
         }, {
            "localId" : "7",
            "locator" : "11:1-11:82",
            "name" : "RequestIntent",
            "id" : "http://terminology.hl7.org/CodeSystem/request-intent",
            "accessLevel" : "Public"
         }, {
            "localId" : "8",
            "locator" : "12:1-12:106",
            "name" : "MedicationRequestCategory",
            "id" : "http://terminology.hl7.org/CodeSystem/medicationrequest-category",
            "accessLevel" : "Public"
         }, {
            "localId" : "9",
            "locator" : "13:1-13:101",
            "name" : "ConditionClinicalStatusCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/condition-clinical",
            "accessLevel" : "Public"
         }, {
            "localId" : "10",
            "locator" : "14:1-14:109",
            "name" : "ConditionVerificationStatusCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/condition-verification",
            "accessLevel" : "Public"
         }, {
            "localId" : "11",
            "locator" : "15:1-15:119",
            "name" : "AllergyIntoleranceClinicalStatusCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical",
            "accessLevel" : "Public"
         }, {
            "localId" : "12",
            "locator" : "16:1-16:127",
            "name" : "AllergyIntoleranceVerificationStatusCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/allergyintolerance-verification",
            "accessLevel" : "Public"
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "13",
            "locator" : "18:1-18:100",
            "name" : "Encounter Inpatient",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307",
            "accessLevel" : "Public"
         }, {
            "localId" : "14",
            "locator" : "19:1-19:111",
            "name" : "Emergency Department Visit",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.117.1.7.1.292",
            "accessLevel" : "Public"
         }, {
            "localId" : "15",
            "locator" : "20:1-20:102",
            "name" : "Observation Services",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1111.143",
            "accessLevel" : "Public"
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "17",
            "locator" : "22:1-22:61",
            "name" : "Birthdate",
            "id" : "21112-8",
            "display" : "Birth date",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "16",
               "locator" : "22:34-22:40",
               "name" : "LOINC"
            }
         }, {
            "localId" : "19",
            "locator" : "23:1-23:55",
            "name" : "Dead",
            "id" : "419099009",
            "display" : "Dead",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "18",
               "locator" : "23:31-23:40",
               "name" : "SNOMEDCT"
            }
         }, {
            "localId" : "21",
            "locator" : "24:1-24:56",
            "name" : "ER",
            "id" : "ER",
            "display" : "Emergency room",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "20",
               "locator" : "24:22-24:31",
               "name" : "RoleCode"
            }
         }, {
            "localId" : "23",
            "locator" : "25:1-25:63",
            "name" : "ICU",
            "id" : "ICU",
            "display" : "Intensive care unit",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "22",
               "locator" : "25:24-25:33",
               "name" : "RoleCode"
            }
         }, {
            "localId" : "25",
            "locator" : "26:1-26:65",
            "name" : "Billing",
            "id" : "billing",
            "display" : "Billing",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "24",
               "locator" : "26:32-26:47",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "27",
            "locator" : "29:1-29:59",
            "name" : "active",
            "id" : "active",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "26",
               "locator" : "29:30-29:59",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "29",
            "locator" : "30:1-30:67",
            "name" : "recurrence",
            "id" : "recurrence",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "28",
               "locator" : "30:38-30:67",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "31",
            "locator" : "31:1-31:61",
            "name" : "relapse",
            "id" : "relapse",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "30",
               "locator" : "31:32-31:61",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "33",
            "locator" : "32:1-32:63",
            "name" : "inactive",
            "id" : "inactive",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "32",
               "locator" : "32:34-32:63",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "35",
            "locator" : "33:1-33:65",
            "name" : "remission",
            "id" : "remission",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "34",
               "locator" : "33:36-33:65",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "37",
            "locator" : "34:1-34:63",
            "name" : "resolved",
            "id" : "resolved",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "36",
               "locator" : "34:34-34:63",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "39",
            "locator" : "37:1-37:71",
            "name" : "unconfirmed",
            "id" : "unconfirmed",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "38",
               "locator" : "37:40-37:71",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "41",
            "locator" : "38:1-38:71",
            "name" : "provisional",
            "id" : "provisional",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "40",
               "locator" : "38:40-38:71",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "43",
            "locator" : "39:1-39:73",
            "name" : "differential",
            "id" : "differential",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "42",
               "locator" : "39:42-39:73",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "45",
            "locator" : "40:1-40:67",
            "name" : "confirmed",
            "id" : "confirmed",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "44",
               "locator" : "40:36-40:67",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "47",
            "locator" : "41:1-41:63",
            "name" : "refuted",
            "id" : "refuted",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "46",
               "locator" : "41:32-41:63",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "49",
            "locator" : "42:1-42:81",
            "name" : "entered-in-error",
            "id" : "entered-in-error",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "48",
               "locator" : "42:50-42:81",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "51",
            "locator" : "44:1-44:76",
            "name" : "allergy-active",
            "id" : "active",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "50",
               "locator" : "44:38-44:76",
               "name" : "AllergyIntoleranceClinicalStatusCodes"
            }
         }, {
            "localId" : "53",
            "locator" : "45:1-45:80",
            "name" : "allergy-inactive",
            "id" : "inactive",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "52",
               "locator" : "45:42-45:80",
               "name" : "AllergyIntoleranceClinicalStatusCodes"
            }
         }, {
            "localId" : "55",
            "locator" : "46:1-46:80",
            "name" : "allergy-resolved",
            "id" : "resolved",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "54",
               "locator" : "46:42-46:80",
               "name" : "AllergyIntoleranceClinicalStatusCodes"
            }
         }, {
            "localId" : "57",
            "locator" : "49:1-49:88",
            "name" : "allergy-unconfirmed",
            "id" : "unconfirmed",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "56",
               "locator" : "49:48-49:88",
               "name" : "AllergyIntoleranceVerificationStatusCodes"
            }
         }, {
            "localId" : "59",
            "locator" : "50:1-50:84",
            "name" : "allergy-confirmed",
            "id" : "confirmed",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "58",
               "locator" : "50:44-50:84",
               "name" : "AllergyIntoleranceVerificationStatusCodes"
            }
         }, {
            "localId" : "61",
            "locator" : "51:1-51:80",
            "name" : "allergy-refuted",
            "id" : "refuted",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "60",
               "locator" : "51:40-51:80",
               "name" : "AllergyIntoleranceVerificationStatusCodes"
            }
         }, {
            "localId" : "63",
            "locator" : "54:1-54:82",
            "name" : "Community",
            "id" : "community",
            "display" : "Community",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "62",
               "locator" : "54:36-54:62",
               "name" : "MedicationRequestCategory"
            }
         }, {
            "localId" : "65",
            "locator" : "55:1-55:82",
            "name" : "Discharge",
            "id" : "discharge",
            "display" : "Discharge",
            "accessLevel" : "Public",
            "codeSystem" : {
               "localId" : "64",
               "locator" : "55:36-55:62",
               "name" : "MedicationRequestCategory"
            }
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "60:1-60:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "60:1-60:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/StructureDefinition/Patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "87",
            "locator" : "89:1-90:59",
            "name" : "LengthInDays",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "87",
                  "s" : [ {
                     "value" : [ "define function ","\"LengthInDays\"","(","Value"," " ]
                  }, {
                     "r" : "81",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "80",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "86",
                     "s" : [ {
                        "r" : "86",
                        "s" : [ {
                           "value" : [ "difference in days between " ]
                        }, {
                           "r" : "83",
                           "s" : [ {
                              "value" : [ "start of " ]
                           }, {
                              "r" : "82",
                              "s" : [ {
                                 "value" : [ "Value" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " and " ]
                        }, {
                           "r" : "85",
                           "s" : [ {
                              "value" : [ "end of " ]
                           }, {
                              "r" : "84",
                              "s" : [ {
                                 "value" : [ "Value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "86",
               "locator" : "90:2-90:59",
               "precision" : "Day",
               "type" : "DifferenceBetween",
               "operand" : [ {
                  "localId" : "83",
                  "locator" : "90:29-90:42",
                  "type" : "Start",
                  "operand" : {
                     "localId" : "82",
                     "locator" : "90:38-90:42",
                     "name" : "Value",
                     "type" : "OperandRef"
                  }
               }, {
                  "localId" : "85",
                  "locator" : "90:48-90:59",
                  "type" : "End",
                  "operand" : {
                     "localId" : "84",
                     "locator" : "90:55-90:59",
                     "name" : "Value",
                     "type" : "OperandRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "Value",
               "operandTypeSpecifier" : {
                  "localId" : "81",
                  "locator" : "89:38-89:55",
                  "type" : "IntervalTypeSpecifier",
                  "pointType" : {
                     "localId" : "80",
                     "locator" : "89:47-89:54",
                     "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "98",
            "locator" : "62:1-66:65",
            "name" : "Inpatient Encounter",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "98",
                  "s" : [ {
                     "value" : [ "define ","\"Inpatient Encounter\"",":\r\n\t" ]
                  }, {
                     "r" : "97",
                     "s" : [ {
                        "s" : [ {
                           "r" : "73",
                           "s" : [ {
                              "r" : "72",
                              "s" : [ {
                                 "r" : "72",
                                 "s" : [ {
                                    "value" : [ "[","Encounter",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"Encounter Inpatient\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","EncounterInpatient" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "96",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "96",
                           "s" : [ {
                              "r" : "91",
                              "s" : [ {
                                 "r" : "77",
                                 "s" : [ {
                                    "r" : "75",
                                    "s" : [ {
                                       "r" : "74",
                                       "s" : [ {
                                          "value" : [ "EncounterInpatient" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "75",
                                       "s" : [ {
                                          "value" : [ "status" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","="," " ]
                                 }, {
                                    "r" : "76",
                                    "s" : [ {
                                       "value" : [ "'finished'" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n\t\t    and " ]
                              }, {
                                 "r" : "90",
                                 "s" : [ {
                                    "r" : "88",
                                    "s" : [ {
                                       "value" : [ "\"LengthInDays\"","(" ]
                                    }, {
                                       "r" : "79",
                                       "s" : [ {
                                          "r" : "78",
                                          "s" : [ {
                                             "value" : [ "EncounterInpatient" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "79",
                                          "s" : [ {
                                             "value" : [ "period" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "r" : "89",
                                    "value" : [ " ","<="," ","120" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\t\t\tand " ]
                           }, {
                              "r" : "95",
                              "s" : [ {
                                 "r" : "93",
                                 "s" : [ {
                                    "r" : "92",
                                    "s" : [ {
                                       "value" : [ "EncounterInpatient" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "93",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "95",
                                 "value" : [ " ","ends during"," " ]
                              }, {
                                 "r" : "94",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "97",
               "locator" : "63:2-66:65",
               "type" : "Query",
               "source" : [ {
                  "localId" : "73",
                  "locator" : "63:2-63:54",
                  "alias" : "EncounterInpatient",
                  "expression" : {
                     "localId" : "72",
                     "locator" : "63:2-63:35",
                     "dataType" : "{http://hl7.org/fhir}Encounter",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                     "codeProperty" : "type",
                     "type" : "Retrieve",
                     "codes" : {
                        "locator" : "63:14-63:34",
                        "name" : "Encounter Inpatient",
                        "type" : "ValueSetRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "96",
                  "locator" : "64:3-66:65",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "91",
                     "locator" : "64:9-65:58",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "77",
                        "locator" : "64:9-64:46",
                        "type" : "Equal",
                        "operand" : [ {
                           "name" : "ToString",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "75",
                              "locator" : "64:9-64:33",
                              "path" : "status",
                              "scope" : "EncounterInpatient",
                              "type" : "Property"
                           } ]
                        }, {
                           "localId" : "76",
                           "locator" : "64:37-64:46",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "finished",
                           "type" : "Literal"
                        } ]
                     }, {
                        "localId" : "90",
                        "locator" : "65:11-65:58",
                        "type" : "LessOrEqual",
                        "operand" : [ {
                           "localId" : "88",
                           "locator" : "65:11-65:51",
                           "name" : "LengthInDays",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "name" : "ToInterval",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "79",
                                 "locator" : "65:26-65:50",
                                 "path" : "period",
                                 "scope" : "EncounterInpatient",
                                 "type" : "Property"
                              } ]
                           } ]
                        }, {
                           "localId" : "89",
                           "locator" : "65:56-65:58",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "120",
                           "type" : "Literal"
                        } ]
                     } ]
                  }, {
                     "localId" : "95",
                     "locator" : "66:8-66:65",
                     "type" : "In",
                     "operand" : [ {
                        "locator" : "66:34-66:37",
                        "type" : "End",
                        "operand" : {
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "93",
                              "locator" : "66:8-66:32",
                              "path" : "period",
                              "scope" : "EncounterInpatient",
                              "type" : "Property"
                           } ]
                        }
                     }, {
                        "localId" : "94",
                        "locator" : "66:46-66:65",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "113",
            "locator" : "68:1-69:99",
            "name" : "ToDate",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "113",
                  "s" : [ {
                     "value" : [ "define function ","\"ToDate\"","(","Value"," " ]
                  }, {
                     "r" : "99",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "112",
                     "s" : [ {
                        "r" : "112",
                        "s" : [ {
                           "value" : [ "DateTime","(" ]
                        }, {
                           "r" : "101",
                           "s" : [ {
                              "value" : [ "year from " ]
                           }, {
                              "r" : "100",
                              "s" : [ {
                                 "value" : [ "Value" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ", " ]
                        }, {
                           "r" : "103",
                           "s" : [ {
                              "value" : [ "month from " ]
                           }, {
                              "r" : "102",
                              "s" : [ {
                                 "value" : [ "Value" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ", " ]
                        }, {
                           "r" : "105",
                           "s" : [ {
                              "value" : [ "day from " ]
                           }, {
                              "r" : "104",
                              "s" : [ {
                                 "value" : [ "Value" ]
                              } ]
                           } ]
                        }, {
                           "r" : "106",
                           "value" : [ ", ","0",", ","0",", ","0",", ","0",", " ]
                        }, {
                           "r" : "111",
                           "s" : [ {
                              "value" : [ "timezoneoffset from " ]
                           }, {
                              "r" : "110",
                              "s" : [ {
                                 "value" : [ "Value" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "112",
               "locator" : "69:2-69:99",
               "type" : "DateTime",
               "year" : {
                  "localId" : "101",
                  "locator" : "69:11-69:25",
                  "precision" : "Year",
                  "type" : "DateTimeComponentFrom",
                  "operand" : {
                     "localId" : "100",
                     "locator" : "69:21-69:25",
                     "name" : "Value",
                     "type" : "OperandRef"
                  }
               },
               "month" : {
                  "localId" : "103",
                  "locator" : "69:28-69:43",
                  "precision" : "Month",
                  "type" : "DateTimeComponentFrom",
                  "operand" : {
                     "localId" : "102",
                     "locator" : "69:39-69:43",
                     "name" : "Value",
                     "type" : "OperandRef"
                  }
               },
               "day" : {
                  "localId" : "105",
                  "locator" : "69:46-69:59",
                  "precision" : "Day",
                  "type" : "DateTimeComponentFrom",
                  "operand" : {
                     "localId" : "104",
                     "locator" : "69:55-69:59",
                     "name" : "Value",
                     "type" : "OperandRef"
                  }
               },
               "hour" : {
                  "localId" : "106",
                  "locator" : "69:62",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "minute" : {
                  "localId" : "107",
                  "locator" : "69:65",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "second" : {
                  "localId" : "108",
                  "locator" : "69:68",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "millisecond" : {
                  "localId" : "109",
                  "locator" : "69:71",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "timezoneOffset" : {
                  "localId" : "111",
                  "locator" : "69:74-69:98",
                  "type" : "TimezoneOffsetFrom",
                  "operand" : {
                     "localId" : "110",
                     "locator" : "69:94-69:98",
                     "name" : "Value",
                     "type" : "OperandRef"
                  }
               }
            },
            "operand" : [ {
               "name" : "Value",
               "operandTypeSpecifier" : {
                  "localId" : "99",
                  "locator" : "68:32-68:39",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "121",
            "locator" : "71:1-72:51",
            "name" : "CalendarAgeInDaysAt",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "121",
                  "s" : [ {
                     "value" : [ "define function ","\"CalendarAgeInDaysAt\"","(","BirthDateTime"," " ]
                  }, {
                     "r" : "114",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ ", ","AsOf"," " ]
                  }, {
                     "r" : "115",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "120",
                     "s" : [ {
                        "r" : "120",
                        "s" : [ {
                           "value" : [ "days between " ]
                        }, {
                           "r" : "117",
                           "s" : [ {
                              "value" : [ "ToDate","(" ]
                           }, {
                              "r" : "116",
                              "s" : [ {
                                 "value" : [ "BirthDateTime" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ "and " ]
                        }, {
                           "r" : "119",
                           "s" : [ {
                              "value" : [ "ToDate","(" ]
                           }, {
                              "r" : "118",
                              "s" : [ {
                                 "value" : [ "AsOf" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "120",
               "locator" : "72:2-72:51",
               "precision" : "Day",
               "type" : "DurationBetween",
               "operand" : [ {
                  "localId" : "117",
                  "locator" : "72:15-72:35",
                  "name" : "ToDate",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "116",
                     "locator" : "72:22-72:34",
                     "name" : "BirthDateTime",
                     "type" : "OperandRef"
                  } ]
               }, {
                  "localId" : "119",
                  "locator" : "72:40-72:51",
                  "name" : "ToDate",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "118",
                     "locator" : "72:47-72:50",
                     "name" : "AsOf",
                     "type" : "OperandRef"
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "BirthDateTime",
               "operandTypeSpecifier" : {
                  "localId" : "114",
                  "locator" : "71:53-71:60",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "AsOf",
               "operandTypeSpecifier" : {
                  "localId" : "115",
                  "locator" : "71:68-71:75",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "126",
            "locator" : "74:1-75:44",
            "name" : "CalendarAgeInDays",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "126",
                  "s" : [ {
                     "value" : [ "define function ","\"CalendarAgeInDays\"","(","BirthDateTime"," " ]
                  }, {
                     "r" : "122",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "125",
                     "s" : [ {
                        "r" : "125",
                        "s" : [ {
                           "value" : [ "CalendarAgeInDaysAt","(" ]
                        }, {
                           "r" : "123",
                           "s" : [ {
                              "value" : [ "BirthDateTime" ]
                           } ]
                        }, {
                           "value" : [ ", " ]
                        }, {
                           "r" : "124",
                           "s" : [ {
                              "value" : [ "Today","()" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "125",
               "locator" : "75:2-75:44",
               "name" : "CalendarAgeInDaysAt",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "123",
                  "locator" : "75:22-75:34",
                  "name" : "BirthDateTime",
                  "type" : "OperandRef"
               }, {
                  "type" : "ToDateTime",
                  "operand" : {
                     "localId" : "124",
                     "locator" : "75:37-75:43",
                     "type" : "Today"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "BirthDateTime",
               "operandTypeSpecifier" : {
                  "localId" : "122",
                  "locator" : "74:51-74:58",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "134",
            "locator" : "77:1-78:53",
            "name" : "CalendarAgeInMonthsAt",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "134",
                  "s" : [ {
                     "value" : [ "define function ","\"CalendarAgeInMonthsAt\"","(","BirthDateTime"," " ]
                  }, {
                     "r" : "127",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ ", ","AsOf"," " ]
                  }, {
                     "r" : "128",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "133",
                     "s" : [ {
                        "r" : "133",
                        "s" : [ {
                           "value" : [ "months between " ]
                        }, {
                           "r" : "130",
                           "s" : [ {
                              "value" : [ "ToDate","(" ]
                           }, {
                              "r" : "129",
                              "s" : [ {
                                 "value" : [ "BirthDateTime" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ "and " ]
                        }, {
                           "r" : "132",
                           "s" : [ {
                              "value" : [ "ToDate","(" ]
                           }, {
                              "r" : "131",
                              "s" : [ {
                                 "value" : [ "AsOf" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "133",
               "locator" : "78:2-78:53",
               "precision" : "Month",
               "type" : "DurationBetween",
               "operand" : [ {
                  "localId" : "130",
                  "locator" : "78:17-78:37",
                  "name" : "ToDate",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "129",
                     "locator" : "78:24-78:36",
                     "name" : "BirthDateTime",
                     "type" : "OperandRef"
                  } ]
               }, {
                  "localId" : "132",
                  "locator" : "78:42-78:53",
                  "name" : "ToDate",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "131",
                     "locator" : "78:49-78:52",
                     "name" : "AsOf",
                     "type" : "OperandRef"
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "BirthDateTime",
               "operandTypeSpecifier" : {
                  "localId" : "127",
                  "locator" : "77:55-77:62",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "AsOf",
               "operandTypeSpecifier" : {
                  "localId" : "128",
                  "locator" : "77:70-77:77",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "139",
            "locator" : "80:1-81:46",
            "name" : "CalendarAgeInMonths",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "139",
                  "s" : [ {
                     "value" : [ "define function ","\"CalendarAgeInMonths\"","(","BirthDateTime"," " ]
                  }, {
                     "r" : "135",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "138",
                     "s" : [ {
                        "r" : "138",
                        "s" : [ {
                           "value" : [ "CalendarAgeInMonthsAt","(" ]
                        }, {
                           "r" : "136",
                           "s" : [ {
                              "value" : [ "BirthDateTime" ]
                           } ]
                        }, {
                           "value" : [ ", " ]
                        }, {
                           "r" : "137",
                           "s" : [ {
                              "value" : [ "Today","()" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "138",
               "locator" : "81:2-81:46",
               "name" : "CalendarAgeInMonthsAt",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "136",
                  "locator" : "81:24-81:36",
                  "name" : "BirthDateTime",
                  "type" : "OperandRef"
               }, {
                  "type" : "ToDateTime",
                  "operand" : {
                     "localId" : "137",
                     "locator" : "81:39-81:45",
                     "type" : "Today"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "BirthDateTime",
               "operandTypeSpecifier" : {
                  "localId" : "135",
                  "locator" : "80:53-80:60",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "147",
            "locator" : "83:1-84:52",
            "name" : "CalendarAgeInYearsAt",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "147",
                  "s" : [ {
                     "value" : [ "define function ","\"CalendarAgeInYearsAt\"","(","BirthDateTime"," " ]
                  }, {
                     "r" : "140",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ ", ","AsOf"," " ]
                  }, {
                     "r" : "141",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "146",
                     "s" : [ {
                        "r" : "146",
                        "s" : [ {
                           "value" : [ "years between " ]
                        }, {
                           "r" : "143",
                           "s" : [ {
                              "value" : [ "ToDate","(" ]
                           }, {
                              "r" : "142",
                              "s" : [ {
                                 "value" : [ "BirthDateTime" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ "and " ]
                        }, {
                           "r" : "145",
                           "s" : [ {
                              "value" : [ "ToDate","(" ]
                           }, {
                              "r" : "144",
                              "s" : [ {
                                 "value" : [ "AsOf" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "146",
               "locator" : "84:2-84:52",
               "precision" : "Year",
               "type" : "DurationBetween",
               "operand" : [ {
                  "localId" : "143",
                  "locator" : "84:16-84:36",
                  "name" : "ToDate",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "142",
                     "locator" : "84:23-84:35",
                     "name" : "BirthDateTime",
                     "type" : "OperandRef"
                  } ]
               }, {
                  "localId" : "145",
                  "locator" : "84:41-84:52",
                  "name" : "ToDate",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "144",
                     "locator" : "84:48-84:51",
                     "name" : "AsOf",
                     "type" : "OperandRef"
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "BirthDateTime",
               "operandTypeSpecifier" : {
                  "localId" : "140",
                  "locator" : "83:54-83:61",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "AsOf",
               "operandTypeSpecifier" : {
                  "localId" : "141",
                  "locator" : "83:69-83:76",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "152",
            "locator" : "86:1-87:45",
            "name" : "CalendarAgeInYears",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "152",
                  "s" : [ {
                     "value" : [ "define function ","\"CalendarAgeInYears\"","(","BirthDateTime"," " ]
                  }, {
                     "r" : "148",
                     "s" : [ {
                        "value" : [ "DateTime" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "151",
                     "s" : [ {
                        "r" : "151",
                        "s" : [ {
                           "value" : [ "CalendarAgeInYearsAt","(" ]
                        }, {
                           "r" : "149",
                           "s" : [ {
                              "value" : [ "BirthDateTime" ]
                           } ]
                        }, {
                           "value" : [ ", " ]
                        }, {
                           "r" : "150",
                           "s" : [ {
                              "value" : [ "Today","()" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "151",
               "locator" : "87:2-87:45",
               "name" : "CalendarAgeInYearsAt",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "149",
                  "locator" : "87:23-87:35",
                  "name" : "BirthDateTime",
                  "type" : "OperandRef"
               }, {
                  "type" : "ToDateTime",
                  "operand" : {
                     "localId" : "150",
                     "locator" : "87:38-87:44",
                     "type" : "Today"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "BirthDateTime",
               "operandTypeSpecifier" : {
                  "localId" : "148",
                  "locator" : "86:52-86:59",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "175",
            "locator" : "92:1-97:5",
            "name" : "ED Visit",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "175",
                  "s" : [ {
                     "value" : [ "define function ","\"ED Visit\"","(","TheEncounter"," " ]
                  }, {
                     "r" : "156",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n    " ]
                  }, {
                     "r" : "174",
                     "s" : [ {
                        "r" : "174",
                        "s" : [ {
                           "value" : [ "singleton from " ]
                        }, {
                           "r" : "173",
                           "s" : [ {
                              "value" : [ "(\r\n        " ]
                           }, {
                              "r" : "173",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "158",
                                    "s" : [ {
                                       "r" : "157",
                                       "s" : [ {
                                          "r" : "157",
                                          "s" : [ {
                                             "value" : [ "[","Encounter",": " ]
                                          }, {
                                             "s" : [ {
                                                "value" : [ "\"Emergency Department Visit\"" ]
                                             } ]
                                          }, {
                                             "value" : [ "]" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","EDVisit" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n            " ]
                              }, {
                                 "r" : "172",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "172",
                                    "s" : [ {
                                       "r" : "162",
                                       "s" : [ {
                                          "r" : "160",
                                          "s" : [ {
                                             "r" : "159",
                                             "s" : [ {
                                                "value" : [ "EDVisit" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "160",
                                             "s" : [ {
                                                "value" : [ "status" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","="," " ]
                                       }, {
                                          "r" : "161",
                                          "s" : [ {
                                             "value" : [ "'finished'" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n                and " ]
                                    }, {
                                       "r" : "171",
                                       "s" : [ {
                                          "r" : "164",
                                          "s" : [ {
                                             "r" : "163",
                                             "s" : [ {
                                                "value" : [ "EDVisit" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "164",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " " ]
                                       }, {
                                          "r" : "171",
                                          "s" : [ {
                                             "value" : [ "ends " ]
                                          }, {
                                             "r" : "170",
                                             "s" : [ {
                                                "value" : [ "1 ","hour" ]
                                             } ]
                                          }, {
                                             "value" : [ " or less on or before" ]
                                          } ]
                                       }, {
                                          "value" : [ " " ]
                                       }, {
                                          "r" : "169",
                                          "s" : [ {
                                             "value" : [ "start of " ]
                                          }, {
                                             "r" : "168",
                                             "s" : [ {
                                                "r" : "165",
                                                "s" : [ {
                                                   "value" : [ "FHIRHelpers" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "168",
                                                "s" : [ {
                                                   "value" : [ "ToInterval","(" ]
                                                }, {
                                                   "r" : "167",
                                                   "s" : [ {
                                                      "r" : "166",
                                                      "s" : [ {
                                                         "value" : [ "TheEncounter" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "167",
                                                      "s" : [ {
                                                         "value" : [ "period" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n    )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "174",
               "locator" : "93:5-97:5",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "173",
                  "locator" : "93:20-97:5",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "158",
                     "locator" : "94:9-94:57",
                     "alias" : "EDVisit",
                     "expression" : {
                        "localId" : "157",
                        "locator" : "94:9-94:49",
                        "dataType" : "{http://hl7.org/fhir}Encounter",
                        "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                        "codeProperty" : "type",
                        "type" : "Retrieve",
                        "codes" : {
                           "locator" : "94:21-94:48",
                           "name" : "Emergency Department Visit",
                           "type" : "ValueSetRef"
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "172",
                     "locator" : "95:13-96:120",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "162",
                        "locator" : "95:19-95:45",
                        "type" : "Equal",
                        "operand" : [ {
                           "name" : "ToString",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "160",
                              "locator" : "95:19-95:32",
                              "path" : "status",
                              "scope" : "EDVisit",
                              "type" : "Property"
                           } ]
                        }, {
                           "localId" : "161",
                           "locator" : "95:36-95:45",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "finished",
                           "type" : "Literal"
                        } ]
                     }, {
                        "localId" : "171",
                        "locator" : "96:21-96:120",
                        "type" : "And",
                        "operand" : [ {
                           "locator" : "96:41-96:54",
                           "type" : "In",
                           "operand" : [ {
                              "locator" : "96:36-96:39",
                              "type" : "End",
                              "operand" : {
                                 "name" : "ToInterval",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "164",
                                    "locator" : "96:21-96:34",
                                    "path" : "period",
                                    "scope" : "EDVisit",
                                    "type" : "Property"
                                 } ]
                              }
                           }, {
                              "locator" : "96:41-96:54",
                              "lowClosed" : true,
                              "highClosed" : true,
                              "type" : "Interval",
                              "low" : {
                                 "locator" : "96:69-96:120",
                                 "type" : "Subtract",
                                 "operand" : [ {
                                    "localId" : "169",
                                    "locator" : "96:69-96:120",
                                    "type" : "Start",
                                    "operand" : {
                                       "localId" : "168",
                                       "locator" : "96:78-96:120",
                                       "name" : "ToInterval",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "167",
                                          "locator" : "96:101-96:119",
                                          "path" : "period",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "166",
                                             "locator" : "96:101-96:112",
                                             "name" : "TheEncounter",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    }
                                 }, {
                                    "localId" : "170",
                                    "locator" : "96:41-96:46",
                                    "value" : 1,
                                    "unit" : "hour",
                                    "type" : "Quantity"
                                 } ]
                              },
                              "high" : {
                                 "localId" : "169",
                                 "locator" : "96:69-96:120",
                                 "type" : "Start",
                                 "operand" : {
                                    "localId" : "168",
                                    "locator" : "96:78-96:120",
                                    "name" : "ToInterval",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "167",
                                       "locator" : "96:101-96:119",
                                       "path" : "period",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "166",
                                          "locator" : "96:101-96:112",
                                          "name" : "TheEncounter",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 }
                              }
                           } ]
                        }, {
                           "locator" : "96:41-96:54",
                           "type" : "Not",
                           "operand" : {
                              "locator" : "96:41-96:54",
                              "type" : "IsNull",
                              "operand" : {
                                 "localId" : "169",
                                 "locator" : "96:69-96:120",
                                 "type" : "Start",
                                 "operand" : {
                                    "localId" : "168",
                                    "locator" : "96:78-96:120",
                                    "name" : "ToInterval",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "167",
                                       "locator" : "96:101-96:119",
                                       "path" : "period",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "166",
                                          "locator" : "96:101-96:112",
                                          "name" : "TheEncounter",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 }
                              }
                           }
                        } ]
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "TheEncounter",
               "operandTypeSpecifier" : {
                  "localId" : "156",
                  "locator" : "92:41-92:54",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "198",
            "locator" : "99:1-103:116",
            "name" : "Hospitalization",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "198",
                  "s" : [ {
                     "value" : [ "define function ","\"Hospitalization\"","(","TheEncounter"," " ]
                  }, {
                     "r" : "176",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "197",
                     "s" : [ {
                        "r" : "197",
                        "s" : [ {
                           "s" : [ {
                              "r" : "179",
                              "s" : [ {
                                 "r" : "178",
                                 "s" : [ {
                                    "value" : [ "( " ]
                                 }, {
                                    "r" : "178",
                                    "s" : [ {
                                       "value" : [ "\"ED Visit\"","(" ]
                                    }, {
                                       "r" : "177",
                                       "s" : [ {
                                          "value" : [ "TheEncounter" ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ " )" ]
                                 } ]
                              }, {
                                 "value" : [ " ","X" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n    " ]
                        }, {
                           "r" : "196",
                           "s" : [ {
                              "value" : [ "return\r\n        " ]
                           }, {
                              "r" : "195",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "181",
                                 "s" : [ {
                                    "r" : "180",
                                    "s" : [ {
                                       "value" : [ "X" ]
                                    } ]
                                 }, {
                                    "value" : [ " is null" ]
                                 } ]
                              }, {
                                 "value" : [ " then " ]
                              }, {
                                 "r" : "183",
                                 "s" : [ {
                                    "r" : "182",
                                    "s" : [ {
                                       "value" : [ "TheEncounter" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "183",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n        else " ]
                              }, {
                                 "r" : "194",
                                 "s" : [ {
                                    "value" : [ "Interval[" ]
                                 }, {
                                    "r" : "188",
                                    "s" : [ {
                                       "value" : [ "start of " ]
                                    }, {
                                       "r" : "187",
                                       "s" : [ {
                                          "r" : "184",
                                          "s" : [ {
                                             "value" : [ "FHIRHelpers" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "187",
                                          "s" : [ {
                                             "value" : [ "ToInterval","(" ]
                                          }, {
                                             "r" : "186",
                                             "s" : [ {
                                                "r" : "185",
                                                "s" : [ {
                                                   "value" : [ "X" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "186",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "193",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "192",
                                       "s" : [ {
                                          "r" : "189",
                                          "s" : [ {
                                             "value" : [ "FHIRHelpers" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "192",
                                          "s" : [ {
                                             "value" : [ "ToInterval","(" ]
                                          }, {
                                             "r" : "191",
                                             "s" : [ {
                                                "r" : "190",
                                                "s" : [ {
                                                   "value" : [ "TheEncounter" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "191",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "197",
               "locator" : "100:2-103:116",
               "type" : "Query",
               "source" : [ {
                  "localId" : "179",
                  "locator" : "100:2-100:31",
                  "alias" : "X",
                  "expression" : {
                     "localId" : "178",
                     "locator" : "100:2-100:29",
                     "name" : "ED Visit",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "177",
                        "locator" : "100:15-100:26",
                        "name" : "TheEncounter",
                        "type" : "OperandRef"
                     } ]
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "196",
                  "locator" : "101:5-103:116",
                  "expression" : {
                     "localId" : "195",
                     "locator" : "102:9-103:116",
                     "type" : "If",
                     "condition" : {
                        "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                        "type" : "As",
                        "operand" : {
                           "localId" : "181",
                           "locator" : "102:12-102:20",
                           "type" : "IsNull",
                           "operand" : {
                              "localId" : "180",
                              "locator" : "102:12",
                              "name" : "X",
                              "type" : "AliasRef"
                           }
                        }
                     },
                     "then" : {
                        "name" : "ToInterval",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "183",
                           "locator" : "102:27-102:45",
                           "path" : "period",
                           "type" : "Property",
                           "source" : {
                              "localId" : "182",
                              "locator" : "102:27-102:38",
                              "name" : "TheEncounter",
                              "type" : "OperandRef"
                           }
                        } ]
                     },
                     "else" : {
                        "localId" : "194",
                        "locator" : "103:14-103:116",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "188",
                           "locator" : "103:23-103:63",
                           "type" : "Start",
                           "operand" : {
                              "localId" : "187",
                              "locator" : "103:32-103:63",
                              "name" : "ToInterval",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "186",
                                 "locator" : "103:55-103:62",
                                 "path" : "period",
                                 "scope" : "X",
                                 "type" : "Property"
                              } ]
                           }
                        },
                        "high" : {
                           "localId" : "193",
                           "locator" : "103:66-103:115",
                           "type" : "End",
                           "operand" : {
                              "localId" : "192",
                              "locator" : "103:73-103:115",
                              "name" : "ToInterval",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "191",
                                 "locator" : "103:96-103:114",
                                 "path" : "period",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "190",
                                    "locator" : "103:96-103:107",
                                    "name" : "TheEncounter",
                                    "type" : "OperandRef"
                                 }
                              } ]
                           }
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "TheEncounter",
               "operandTypeSpecifier" : {
                  "localId" : "176",
                  "locator" : "99:48-99:61",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "216",
            "locator" : "105:1-109:68",
            "name" : "Hospitalization Locations",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "216",
                  "s" : [ {
                     "value" : [ "define function ","\"Hospitalization Locations\"","(","TheEncounter"," " ]
                  }, {
                     "r" : "199",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "215",
                     "s" : [ {
                        "r" : "215",
                        "s" : [ {
                           "s" : [ {
                              "r" : "202",
                              "s" : [ {
                                 "r" : "201",
                                 "s" : [ {
                                    "value" : [ "( " ]
                                 }, {
                                    "r" : "201",
                                    "s" : [ {
                                       "value" : [ "\"ED Visit\"","(" ]
                                    }, {
                                       "r" : "200",
                                       "s" : [ {
                                          "value" : [ "TheEncounter" ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ " )" ]
                                 } ]
                              }, {
                                 "value" : [ " ","EDEncounter" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n    " ]
                        }, {
                           "r" : "214",
                           "s" : [ {
                              "value" : [ "return\r\n        " ]
                           }, {
                              "r" : "213",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "204",
                                 "s" : [ {
                                    "r" : "203",
                                    "s" : [ {
                                       "value" : [ "EDEncounter" ]
                                    } ]
                                 }, {
                                    "value" : [ " is null" ]
                                 } ]
                              }, {
                                 "value" : [ " then " ]
                              }, {
                                 "r" : "206",
                                 "s" : [ {
                                    "r" : "205",
                                    "s" : [ {
                                       "value" : [ "TheEncounter" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "206",
                                    "s" : [ {
                                       "value" : [ "location" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n        else " ]
                              }, {
                                 "r" : "212",
                                 "s" : [ {
                                    "value" : [ "flatten " ]
                                 }, {
                                    "r" : "211",
                                    "s" : [ {
                                       "value" : [ "{ " ]
                                    }, {
                                       "r" : "208",
                                       "s" : [ {
                                          "r" : "207",
                                          "s" : [ {
                                             "value" : [ "EDEncounter" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "208",
                                          "s" : [ {
                                             "value" : [ "location" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "210",
                                       "s" : [ {
                                          "r" : "209",
                                          "s" : [ {
                                             "value" : [ "TheEncounter" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "210",
                                          "s" : [ {
                                             "value" : [ "location" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " }" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "215",
               "locator" : "106:2-109:68",
               "type" : "Query",
               "source" : [ {
                  "localId" : "202",
                  "locator" : "106:2-106:41",
                  "alias" : "EDEncounter",
                  "expression" : {
                     "localId" : "201",
                     "locator" : "106:2-106:29",
                     "name" : "ED Visit",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "200",
                        "locator" : "106:15-106:26",
                        "name" : "TheEncounter",
                        "type" : "OperandRef"
                     } ]
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "214",
                  "locator" : "107:5-109:68",
                  "expression" : {
                     "localId" : "213",
                     "locator" : "108:9-109:68",
                     "type" : "If",
                     "condition" : {
                        "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                        "type" : "As",
                        "operand" : {
                           "localId" : "204",
                           "locator" : "108:12-108:30",
                           "type" : "IsNull",
                           "operand" : {
                              "localId" : "203",
                              "locator" : "108:12-108:22",
                              "name" : "EDEncounter",
                              "type" : "AliasRef"
                           }
                        }
                     },
                     "then" : {
                        "localId" : "206",
                        "locator" : "108:37-108:57",
                        "path" : "location",
                        "type" : "Property",
                        "source" : {
                           "localId" : "205",
                           "locator" : "108:37-108:48",
                           "name" : "TheEncounter",
                           "type" : "OperandRef"
                        }
                     },
                     "else" : {
                        "localId" : "212",
                        "locator" : "109:14-109:68",
                        "type" : "Flatten",
                        "operand" : {
                           "localId" : "211",
                           "locator" : "109:22-109:68",
                           "type" : "List",
                           "element" : [ {
                              "localId" : "208",
                              "locator" : "109:24-109:43",
                              "path" : "location",
                              "scope" : "EDEncounter",
                              "type" : "Property"
                           }, {
                              "localId" : "210",
                              "locator" : "109:46-109:66",
                              "path" : "location",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "209",
                                 "locator" : "109:46-109:57",
                                 "name" : "TheEncounter",
                                 "type" : "OperandRef"
                              }
                           } ]
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "TheEncounter",
               "operandTypeSpecifier" : {
                  "localId" : "199",
                  "locator" : "105:58-105:71",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "221",
            "locator" : "111:1-112:46",
            "name" : "Hospitalization Length of Stay",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "221",
                  "s" : [ {
                     "value" : [ "define function ","\"Hospitalization Length of Stay\"","(","TheEncounter"," " ]
                  }, {
                     "r" : "217",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "220",
                     "s" : [ {
                        "r" : "220",
                        "s" : [ {
                           "value" : [ "LengthInDays","(" ]
                        }, {
                           "r" : "219",
                           "s" : [ {
                              "value" : [ "\"Hospitalization\"","(" ]
                           }, {
                              "r" : "218",
                              "s" : [ {
                                 "value" : [ "TheEncounter" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "220",
               "locator" : "112:2-112:46",
               "name" : "LengthInDays",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "219",
                  "locator" : "112:15-112:45",
                  "name" : "Hospitalization",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "218",
                     "locator" : "112:33-112:44",
                     "name" : "TheEncounter",
                     "type" : "OperandRef"
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "TheEncounter",
               "operandTypeSpecifier" : {
                  "localId" : "217",
                  "locator" : "111:63-111:76",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "226",
            "locator" : "114:1-115:41",
            "name" : "Hospital Admission Time",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "226",
                  "s" : [ {
                     "value" : [ "define function ","\"Hospital Admission Time\"","(","TheEncounter"," " ]
                  }, {
                     "r" : "222",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "225",
                     "s" : [ {
                        "r" : "225",
                        "s" : [ {
                           "value" : [ "start of " ]
                        }, {
                           "r" : "224",
                           "s" : [ {
                              "value" : [ "\"Hospitalization\"","(" ]
                           }, {
                              "r" : "223",
                              "s" : [ {
                                 "value" : [ "TheEncounter" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "225",
               "locator" : "115:2-115:41",
               "type" : "Start",
               "operand" : {
                  "localId" : "224",
                  "locator" : "115:11-115:41",
                  "name" : "Hospitalization",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "223",
                     "locator" : "115:29-115:40",
                     "name" : "TheEncounter",
                     "type" : "OperandRef"
                  } ]
               }
            },
            "operand" : [ {
               "name" : "TheEncounter",
               "operandTypeSpecifier" : {
                  "localId" : "222",
                  "locator" : "114:56-114:69",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "233",
            "locator" : "117:1-118:51",
            "name" : "Hospital Discharge Time",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "233",
                  "s" : [ {
                     "value" : [ "define function ","\"Hospital Discharge Time\"","(","TheEncounter"," " ]
                  }, {
                     "r" : "227",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "232",
                     "s" : [ {
                        "r" : "232",
                        "s" : [ {
                           "value" : [ "end of " ]
                        }, {
                           "r" : "231",
                           "s" : [ {
                              "r" : "228",
                              "s" : [ {
                                 "value" : [ "FHIRHelpers" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "231",
                              "s" : [ {
                                 "value" : [ "ToInterval","(" ]
                              }, {
                                 "r" : "230",
                                 "s" : [ {
                                    "r" : "229",
                                    "s" : [ {
                                       "value" : [ "TheEncounter" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "230",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "232",
               "locator" : "118:2-118:51",
               "type" : "End",
               "operand" : {
                  "localId" : "231",
                  "locator" : "118:9-118:51",
                  "name" : "ToInterval",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "230",
                     "locator" : "118:32-118:50",
                     "path" : "period",
                     "type" : "Property",
                     "source" : {
                        "localId" : "229",
                        "locator" : "118:32-118:43",
                        "name" : "TheEncounter",
                        "type" : "OperandRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "TheEncounter",
               "operandTypeSpecifier" : {
                  "localId" : "227",
                  "locator" : "117:56-117:69",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "250",
            "locator" : "120:1-124:10",
            "name" : "Hospital Arrival Time",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "250",
                  "s" : [ {
                     "value" : [ "define function ","\"Hospital Arrival Time\"","(","TheEncounter"," " ]
                  }, {
                     "r" : "234",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "249",
                     "s" : [ {
                        "r" : "249",
                        "s" : [ {
                           "value" : [ "start of " ]
                        }, {
                           "r" : "248",
                           "s" : [ {
                              "r" : "235",
                              "s" : [ {
                                 "value" : [ "FHIRHelpers" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "248",
                              "s" : [ {
                                 "value" : [ "ToInterval","(" ]
                              }, {
                                 "r" : "247",
                                 "s" : [ {
                                    "r" : "246",
                                    "s" : [ {
                                       "value" : [ "First","(\r\n\t    " ]
                                    }, {
                                       "r" : "245",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "238",
                                             "s" : [ {
                                                "r" : "237",
                                                "s" : [ {
                                                   "value" : [ "( " ]
                                                }, {
                                                   "r" : "237",
                                                   "s" : [ {
                                                      "value" : [ "\"Hospitalization Locations\"","(" ]
                                                   }, {
                                                      "r" : "236",
                                                      "s" : [ {
                                                         "value" : [ "TheEncounter" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ ")" ]
                                                   } ]
                                                }, {
                                                   "value" : [ " )" ]
                                                } ]
                                             }, {
                                                "value" : [ " ","HospitalLocation" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\r\n\t\t\t" ]
                                       }, {
                                          "r" : "244",
                                          "s" : [ {
                                             "value" : [ "sort by " ]
                                          }, {
                                             "r" : "243",
                                             "s" : [ {
                                                "r" : "242",
                                                "s" : [ {
                                                   "value" : [ "start of " ]
                                                }, {
                                                   "r" : "241",
                                                   "s" : [ {
                                                      "r" : "239",
                                                      "s" : [ {
                                                         "value" : [ "FHIRHelpers" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "241",
                                                      "s" : [ {
                                                         "value" : [ "ToInterval","(" ]
                                                      }, {
                                                         "r" : "240",
                                                         "s" : [ {
                                                            "value" : [ "period" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ ")" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n\t)" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "247",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "249",
               "locator" : "121:2-124:10",
               "type" : "Start",
               "operand" : {
                  "localId" : "248",
                  "locator" : "121:11-124:10",
                  "name" : "ToInterval",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "247",
                     "locator" : "121:34-124:9",
                     "path" : "period",
                     "type" : "Property",
                     "source" : {
                        "localId" : "246",
                        "locator" : "121:34-124:2",
                        "type" : "First",
                        "source" : {
                           "localId" : "245",
                           "locator" : "122:6-123:50",
                           "type" : "Query",
                           "source" : [ {
                              "localId" : "238",
                              "locator" : "122:6-122:67",
                              "alias" : "HospitalLocation",
                              "expression" : {
                                 "localId" : "237",
                                 "locator" : "122:6-122:50",
                                 "name" : "Hospitalization Locations",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "236",
                                    "locator" : "122:36-122:47",
                                    "name" : "TheEncounter",
                                    "type" : "OperandRef"
                                 } ]
                              }
                           } ],
                           "relationship" : [ ],
                           "sort" : {
                              "localId" : "244",
                              "locator" : "123:4-123:50",
                              "by" : [ {
                                 "localId" : "243",
                                 "locator" : "123:12-123:50",
                                 "direction" : "asc",
                                 "type" : "ByExpression",
                                 "expression" : {
                                    "localId" : "242",
                                    "locator" : "123:12-123:50",
                                    "type" : "Start",
                                    "operand" : {
                                       "localId" : "241",
                                       "locator" : "123:21-123:50",
                                       "name" : "ToInterval",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "240",
                                          "locator" : "123:44-123:49",
                                          "name" : "period",
                                          "type" : "IdentifierRef"
                                       } ]
                                    }
                                 }
                              } ]
                           }
                        }
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "TheEncounter",
               "operandTypeSpecifier" : {
                  "localId" : "234",
                  "locator" : "120:54-120:67",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "303",
            "locator" : "126:1-137:85",
            "name" : "HospitalizationWithObservation",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "303",
                  "s" : [ {
                     "value" : [ "define function ","\"HospitalizationWithObservation\"","(","TheEncounter"," " ]
                  }, {
                     "r" : "251",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "302",
                     "s" : [ {
                        "r" : "302",
                        "s" : [ {
                           "s" : [ {
                              "r" : "253",
                              "s" : [ {
                                 "r" : "252",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "TheEncounter" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","Visit" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "s" : [ {
                              "value" : [ "let " ]
                           }, {
                              "r" : "269",
                              "s" : [ {
                                 "value" : [ "ObsVisit",": " ]
                              }, {
                                 "r" : "268",
                                 "s" : [ {
                                    "value" : [ "Last","(" ]
                                 }, {
                                    "r" : "267",
                                    "s" : [ {
                                       "s" : [ {
                                          "r" : "255",
                                          "s" : [ {
                                             "r" : "254",
                                             "s" : [ {
                                                "r" : "254",
                                                "s" : [ {
                                                   "value" : [ "[","Encounter",": " ]
                                                }, {
                                                   "s" : [ {
                                                      "value" : [ "\"Observation Services\"" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","LastObs" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n\t\t\t\t" ]
                                    }, {
                                       "r" : "262",
                                       "s" : [ {
                                          "value" : [ "where " ]
                                       }, {
                                          "r" : "262",
                                          "s" : [ {
                                             "r" : "257",
                                             "s" : [ {
                                                "r" : "256",
                                                "s" : [ {
                                                   "value" : [ "LastObs" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "257",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " " ]
                                          }, {
                                             "r" : "262",
                                             "s" : [ {
                                                "value" : [ "ends " ]
                                             }, {
                                                "r" : "261",
                                                "s" : [ {
                                                   "value" : [ "1 ","hour" ]
                                                } ]
                                             }, {
                                                "value" : [ " or less on or before" ]
                                             } ]
                                          }, {
                                             "value" : [ " " ]
                                          }, {
                                             "r" : "260",
                                             "s" : [ {
                                                "value" : [ "start of " ]
                                             }, {
                                                "r" : "259",
                                                "s" : [ {
                                                   "r" : "258",
                                                   "s" : [ {
                                                      "value" : [ "Visit" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "259",
                                                   "s" : [ {
                                                      "value" : [ "period" ]
                                                   } ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n\t\t\t\t" ]
                                    }, {
                                       "r" : "266",
                                       "s" : [ {
                                          "value" : [ "sort by " ]
                                       }, {
                                          "r" : "265",
                                          "s" : [ {
                                             "r" : "264",
                                             "s" : [ {
                                                "value" : [ "end of " ]
                                             }, {
                                                "r" : "263",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\r\n\t\t\t)" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\r\n\t\t\t" ]
                           }, {
                              "r" : "277",
                              "s" : [ {
                                 "value" : [ "VisitStart",": " ]
                              }, {
                                 "r" : "276",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "272",
                                    "s" : [ {
                                       "value" : [ "start of " ]
                                    }, {
                                       "r" : "271",
                                       "s" : [ {
                                          "r" : "270",
                                          "s" : [ {
                                             "value" : [ "ObsVisit" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "271",
                                          "s" : [ {
                                             "value" : [ "period" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "275",
                                    "s" : [ {
                                       "value" : [ "start of " ]
                                    }, {
                                       "r" : "274",
                                       "s" : [ {
                                          "r" : "273",
                                          "s" : [ {
                                             "value" : [ "Visit" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "274",
                                          "s" : [ {
                                             "value" : [ "period" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\r\n\t\t\t" ]
                           }, {
                              "r" : "291",
                              "s" : [ {
                                 "value" : [ "EDVisit",": " ]
                              }, {
                                 "r" : "290",
                                 "s" : [ {
                                    "value" : [ "Last","(" ]
                                 }, {
                                    "r" : "289",
                                    "s" : [ {
                                       "s" : [ {
                                          "r" : "279",
                                          "s" : [ {
                                             "r" : "278",
                                             "s" : [ {
                                                "r" : "278",
                                                "s" : [ {
                                                   "value" : [ "[","Encounter",": " ]
                                                }, {
                                                   "s" : [ {
                                                      "value" : [ "\"Emergency Department Visit\"" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","LastED" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n\t\t\t\t" ]
                                    }, {
                                       "r" : "284",
                                       "s" : [ {
                                          "value" : [ "where " ]
                                       }, {
                                          "r" : "284",
                                          "s" : [ {
                                             "r" : "281",
                                             "s" : [ {
                                                "r" : "280",
                                                "s" : [ {
                                                   "value" : [ "LastED" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "281",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " " ]
                                          }, {
                                             "r" : "284",
                                             "s" : [ {
                                                "value" : [ "ends " ]
                                             }, {
                                                "r" : "283",
                                                "s" : [ {
                                                   "value" : [ "1 ","hour" ]
                                                } ]
                                             }, {
                                                "value" : [ " or less on or before" ]
                                             } ]
                                          }, {
                                             "value" : [ " " ]
                                          }, {
                                             "r" : "282",
                                             "s" : [ {
                                                "value" : [ "VisitStart" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n\t\t\t\t" ]
                                    }, {
                                       "r" : "288",
                                       "s" : [ {
                                          "value" : [ "sort by " ]
                                       }, {
                                          "r" : "287",
                                          "s" : [ {
                                             "r" : "286",
                                             "s" : [ {
                                                "value" : [ "end of " ]
                                             }, {
                                                "r" : "285",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\r\n\t\t\t)" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "301",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "300",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "296",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "294",
                                    "s" : [ {
                                       "value" : [ "start of " ]
                                    }, {
                                       "r" : "293",
                                       "s" : [ {
                                          "r" : "292",
                                          "s" : [ {
                                             "value" : [ "EDVisit" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "293",
                                          "s" : [ {
                                             "value" : [ "period" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "295",
                                    "s" : [ {
                                       "value" : [ "VisitStart" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "299",
                                 "s" : [ {
                                    "value" : [ "end of " ]
                                 }, {
                                    "r" : "298",
                                    "s" : [ {
                                       "r" : "297",
                                       "s" : [ {
                                          "value" : [ "Visit" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "298",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "]" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "302",
               "locator" : "127:2-137:85",
               "type" : "Query",
               "source" : [ {
                  "localId" : "253",
                  "locator" : "127:2-127:19",
                  "alias" : "Visit",
                  "expression" : {
                     "localId" : "252",
                     "locator" : "127:2-127:13",
                     "name" : "TheEncounter",
                     "type" : "OperandRef"
                  }
               } ],
               "let" : [ {
                  "localId" : "269",
                  "locator" : "128:7-131:4",
                  "identifier" : "ObsVisit",
                  "expression" : {
                     "localId" : "268",
                     "locator" : "128:17-131:4",
                     "type" : "Last",
                     "source" : {
                        "localId" : "267",
                        "locator" : "128:22-130:25",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "255",
                           "locator" : "128:22-128:64",
                           "alias" : "LastObs",
                           "expression" : {
                              "localId" : "254",
                              "locator" : "128:22-128:56",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                              "codeProperty" : "type",
                              "type" : "Retrieve",
                              "codes" : {
                                 "locator" : "128:34-128:55",
                                 "name" : "Observation Services",
                                 "type" : "ValueSetRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "262",
                           "locator" : "129:5-129:79",
                           "type" : "And",
                           "operand" : [ {
                              "locator" : "129:31-129:44",
                              "type" : "In",
                              "operand" : [ {
                                 "locator" : "129:26-129:29",
                                 "type" : "End",
                                 "operand" : {
                                    "name" : "ToInterval",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "257",
                                       "locator" : "129:11-129:24",
                                       "path" : "period",
                                       "scope" : "LastObs",
                                       "type" : "Property"
                                    } ]
                                 }
                              }, {
                                 "locator" : "129:31-129:44",
                                 "lowClosed" : true,
                                 "highClosed" : true,
                                 "type" : "Interval",
                                 "low" : {
                                    "locator" : "129:59-129:79",
                                    "type" : "Subtract",
                                    "operand" : [ {
                                       "localId" : "260",
                                       "locator" : "129:59-129:79",
                                       "type" : "Start",
                                       "operand" : {
                                          "name" : "ToInterval",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "259",
                                             "locator" : "129:68-129:79",
                                             "path" : "period",
                                             "scope" : "Visit",
                                             "type" : "Property"
                                          } ]
                                       }
                                    }, {
                                       "localId" : "261",
                                       "locator" : "129:31-129:36",
                                       "value" : 1,
                                       "unit" : "hour",
                                       "type" : "Quantity"
                                    } ]
                                 },
                                 "high" : {
                                    "localId" : "260",
                                    "locator" : "129:59-129:79",
                                    "type" : "Start",
                                    "operand" : {
                                       "name" : "ToInterval",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "259",
                                          "locator" : "129:68-129:79",
                                          "path" : "period",
                                          "scope" : "Visit",
                                          "type" : "Property"
                                       } ]
                                    }
                                 }
                              } ]
                           }, {
                              "locator" : "129:31-129:44",
                              "type" : "Not",
                              "operand" : {
                                 "locator" : "129:31-129:44",
                                 "type" : "IsNull",
                                 "operand" : {
                                    "localId" : "260",
                                    "locator" : "129:59-129:79",
                                    "type" : "Start",
                                    "operand" : {
                                       "name" : "ToInterval",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "259",
                                          "locator" : "129:68-129:79",
                                          "path" : "period",
                                          "scope" : "Visit",
                                          "type" : "Property"
                                       } ]
                                    }
                                 }
                              }
                           } ]
                        },
                        "sort" : {
                           "localId" : "266",
                           "locator" : "130:5-130:25",
                           "by" : [ {
                              "localId" : "265",
                              "locator" : "130:13-130:25",
                              "direction" : "asc",
                              "type" : "ByExpression",
                              "expression" : {
                                 "localId" : "264",
                                 "locator" : "130:13-130:25",
                                 "type" : "End",
                                 "operand" : {
                                    "name" : "ToInterval",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "263",
                                       "locator" : "130:20-130:25",
                                       "name" : "period",
                                       "type" : "IdentifierRef"
                                    } ]
                                 }
                              }
                           } ]
                        }
                     }
                  }
               }, {
                  "localId" : "277",
                  "locator" : "132:4-132:72",
                  "identifier" : "VisitStart",
                  "expression" : {
                     "localId" : "276",
                     "locator" : "132:16-132:72",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "272",
                        "locator" : "132:25-132:48",
                        "type" : "Start",
                        "operand" : {
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "271",
                              "locator" : "132:34-132:48",
                              "path" : "period",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "270",
                                 "locator" : "132:34-132:41",
                                 "name" : "ObsVisit",
                                 "type" : "QueryLetRef"
                              }
                           } ]
                        }
                     }, {
                        "localId" : "275",
                        "locator" : "132:51-132:71",
                        "type" : "Start",
                        "operand" : {
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "274",
                              "locator" : "132:60-132:71",
                              "path" : "period",
                              "scope" : "Visit",
                              "type" : "Property"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "291",
                  "locator" : "133:4-136:4",
                  "identifier" : "EDVisit",
                  "expression" : {
                     "localId" : "290",
                     "locator" : "133:13-136:4",
                     "type" : "Last",
                     "source" : {
                        "localId" : "289",
                        "locator" : "133:18-135:25",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "279",
                           "locator" : "133:18-133:65",
                           "alias" : "LastED",
                           "expression" : {
                              "localId" : "278",
                              "locator" : "133:18-133:58",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                              "codeProperty" : "type",
                              "type" : "Retrieve",
                              "codes" : {
                                 "locator" : "133:30-133:57",
                                 "name" : "Emergency Department Visit",
                                 "type" : "ValueSetRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "284",
                           "locator" : "134:5-134:67",
                           "type" : "And",
                           "operand" : [ {
                              "locator" : "134:30-134:43",
                              "type" : "In",
                              "operand" : [ {
                                 "locator" : "134:25-134:28",
                                 "type" : "End",
                                 "operand" : {
                                    "name" : "ToInterval",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "281",
                                       "locator" : "134:11-134:23",
                                       "path" : "period",
                                       "scope" : "LastED",
                                       "type" : "Property"
                                    } ]
                                 }
                              }, {
                                 "locator" : "134:30-134:43",
                                 "lowClosed" : true,
                                 "highClosed" : true,
                                 "type" : "Interval",
                                 "low" : {
                                    "locator" : "134:58-134:67",
                                    "type" : "Subtract",
                                    "operand" : [ {
                                       "localId" : "282",
                                       "locator" : "134:58-134:67",
                                       "name" : "VisitStart",
                                       "type" : "QueryLetRef"
                                    }, {
                                       "localId" : "283",
                                       "locator" : "134:30-134:35",
                                       "value" : 1,
                                       "unit" : "hour",
                                       "type" : "Quantity"
                                    } ]
                                 },
                                 "high" : {
                                    "localId" : "282",
                                    "locator" : "134:58-134:67",
                                    "name" : "VisitStart",
                                    "type" : "QueryLetRef"
                                 }
                              } ]
                           }, {
                              "locator" : "134:30-134:43",
                              "type" : "Not",
                              "operand" : {
                                 "locator" : "134:30-134:43",
                                 "type" : "IsNull",
                                 "operand" : {
                                    "localId" : "282",
                                    "locator" : "134:58-134:67",
                                    "name" : "VisitStart",
                                    "type" : "QueryLetRef"
                                 }
                              }
                           } ]
                        },
                        "sort" : {
                           "localId" : "288",
                           "locator" : "135:5-135:25",
                           "by" : [ {
                              "localId" : "287",
                              "locator" : "135:13-135:25",
                              "direction" : "asc",
                              "type" : "ByExpression",
                              "expression" : {
                                 "localId" : "286",
                                 "locator" : "135:13-135:25",
                                 "type" : "End",
                                 "operand" : {
                                    "name" : "ToInterval",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "285",
                                       "locator" : "135:20-135:25",
                                       "name" : "period",
                                       "type" : "IdentifierRef"
                                    } ]
                                 }
                              }
                           } ]
                        }
                     }
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "301",
                  "locator" : "137:3-137:85",
                  "expression" : {
                     "localId" : "300",
                     "locator" : "137:10-137:85",
                     "lowClosed" : true,
                     "highClosed" : true,
                     "type" : "Interval",
                     "low" : {
                        "localId" : "296",
                        "locator" : "137:19-137:63",
                        "type" : "Coalesce",
                        "operand" : [ {
                           "localId" : "294",
                           "locator" : "137:28-137:50",
                           "type" : "Start",
                           "operand" : {
                              "name" : "ToInterval",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "293",
                                 "locator" : "137:37-137:50",
                                 "path" : "period",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "292",
                                    "locator" : "137:37-137:43",
                                    "name" : "EDVisit",
                                    "type" : "QueryLetRef"
                                 }
                              } ]
                           }
                        }, {
                           "localId" : "295",
                           "locator" : "137:53-137:62",
                           "name" : "VisitStart",
                           "type" : "QueryLetRef"
                        } ]
                     },
                     "high" : {
                        "localId" : "299",
                        "locator" : "137:66-137:84",
                        "type" : "End",
                        "operand" : {
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "298",
                              "locator" : "137:73-137:84",
                              "path" : "period",
                              "scope" : "Visit",
                              "type" : "Property"
                           } ]
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "TheEncounter",
               "operandTypeSpecifier" : {
                  "localId" : "251",
                  "locator" : "126:63-126:76",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "308",
            "locator" : "139:1-140:60",
            "name" : "HospitalizationWithObservationLengthofStay",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "308",
                  "s" : [ {
                     "value" : [ "define function ","\"HospitalizationWithObservationLengthofStay\"","(","Encounter"," " ]
                  }, {
                     "r" : "304",
                     "s" : [ {
                        "value" : [ "FHIR",".","Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "307",
                     "s" : [ {
                        "r" : "307",
                        "s" : [ {
                           "value" : [ "\"LengthInDays\"","(" ]
                        }, {
                           "r" : "306",
                           "s" : [ {
                              "value" : [ "\"HospitalizationWithObservation\"","(" ]
                           }, {
                              "r" : "305",
                              "s" : [ {
                                 "value" : [ "Encounter" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "307",
               "locator" : "140:2-140:60",
               "name" : "LengthInDays",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "306",
                  "locator" : "140:17-140:59",
                  "name" : "HospitalizationWithObservation",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "305",
                     "locator" : "140:50-140:58",
                     "name" : "Encounter",
                     "type" : "OperandRef"
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "Encounter",
               "operandTypeSpecifier" : {
                  "localId" : "304",
                  "locator" : "139:72-139:85",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "443",
            "locator" : "171:1-191:4",
            "name" : "Normalize Interval",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "443",
                  "s" : [ {
                     "value" : [ "define function ","\"Normalize Interval\"","(","choice"," " ]
                  }, {
                     "r" : "316",
                     "s" : [ {
                        "value" : [ "Choice<" ]
                     }, {
                        "r" : "309",
                        "s" : [ {
                           "value" : [ "FHIR",".","dateTime" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "310",
                        "s" : [ {
                           "value" : [ "FHIR",".","Period" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "311",
                        "s" : [ {
                           "value" : [ "FHIR",".","Timing" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "312",
                        "s" : [ {
                           "value" : [ "FHIR",".","instant" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "313",
                        "s" : [ {
                           "value" : [ "FHIR",".","string" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "314",
                        "s" : [ {
                           "value" : [ "FHIR",".","Age" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "315",
                        "s" : [ {
                           "value" : [ "FHIR",".","Range" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "442",
                     "s" : [ {
                        "r" : "442",
                        "s" : [ {
                           "value" : [ "case\r\n\t  " ]
                        }, {
                           "r" : "331",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "319",
                              "s" : [ {
                                 "r" : "317",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "318",
                                 "s" : [ {
                                    "value" : [ "FHIR",".","dateTime" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\r\n    \t" ]
                           }, {
                              "r" : "330",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "324",
                                 "s" : [ {
                                    "r" : "320",
                                    "s" : [ {
                                       "value" : [ "FHIRHelpers" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "324",
                                    "s" : [ {
                                       "value" : [ "ToDateTime","(" ]
                                    }, {
                                       "r" : "323",
                                       "s" : [ {
                                          "r" : "321",
                                          "s" : [ {
                                             "value" : [ "choice" ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "322",
                                          "s" : [ {
                                             "value" : [ "FHIR",".","dateTime" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "329",
                                 "s" : [ {
                                    "r" : "325",
                                    "s" : [ {
                                       "value" : [ "FHIRHelpers" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "329",
                                    "s" : [ {
                                       "value" : [ "ToDateTime","(" ]
                                    }, {
                                       "r" : "328",
                                       "s" : [ {
                                          "r" : "326",
                                          "s" : [ {
                                             "value" : [ "choice" ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "327",
                                          "s" : [ {
                                             "value" : [ "FHIR",".","dateTime" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "340",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "334",
                              "s" : [ {
                                 "r" : "332",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "333",
                                 "s" : [ {
                                    "value" : [ "FHIR",".","Period" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\r\n  \t\t" ]
                           }, {
                              "r" : "339",
                              "s" : [ {
                                 "r" : "335",
                                 "s" : [ {
                                    "value" : [ "FHIRHelpers" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "339",
                                 "s" : [ {
                                    "value" : [ "ToInterval","(" ]
                                 }, {
                                    "r" : "338",
                                    "s" : [ {
                                       "r" : "336",
                                       "s" : [ {
                                          "value" : [ "choice" ]
                                       } ]
                                    }, {
                                       "value" : [ " as " ]
                                    }, {
                                       "r" : "337",
                                       "s" : [ {
                                          "value" : [ "FHIR",".","Period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "355",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "343",
                              "s" : [ {
                                 "r" : "341",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "342",
                                 "s" : [ {
                                    "value" : [ "FHIR",".","instant" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\r\n\t\t\t" ]
                           }, {
                              "r" : "354",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "348",
                                 "s" : [ {
                                    "r" : "344",
                                    "s" : [ {
                                       "value" : [ "FHIRHelpers" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "348",
                                    "s" : [ {
                                       "value" : [ "ToDateTime","(" ]
                                    }, {
                                       "r" : "347",
                                       "s" : [ {
                                          "r" : "345",
                                          "s" : [ {
                                             "value" : [ "choice" ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "346",
                                          "s" : [ {
                                             "value" : [ "FHIR",".","instant" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "353",
                                 "s" : [ {
                                    "r" : "349",
                                    "s" : [ {
                                       "value" : [ "FHIRHelpers" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "353",
                                    "s" : [ {
                                       "value" : [ "ToDateTime","(" ]
                                    }, {
                                       "r" : "352",
                                       "s" : [ {
                                          "r" : "350",
                                          "s" : [ {
                                             "value" : [ "choice" ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "351",
                                          "s" : [ {
                                             "value" : [ "FHIR",".","instant" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "382",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "358",
                              "s" : [ {
                                 "r" : "356",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "357",
                                 "s" : [ {
                                    "value" : [ "FHIR",".","Age" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\r\n\t\t  " ]
                           }, {
                              "r" : "381",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "368",
                                 "s" : [ {
                                    "r" : "362",
                                    "s" : [ {
                                       "r" : "359",
                                       "s" : [ {
                                          "value" : [ "FHIRHelpers" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "362",
                                       "s" : [ {
                                          "value" : [ "ToDate","(" ]
                                       }, {
                                          "r" : "361",
                                          "s" : [ {
                                             "r" : "360",
                                             "s" : [ {
                                                "value" : [ "Patient" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "361",
                                             "s" : [ {
                                                "value" : [ "birthDate" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "367",
                                    "s" : [ {
                                       "r" : "363",
                                       "s" : [ {
                                          "value" : [ "FHIRHelpers" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "367",
                                       "s" : [ {
                                          "value" : [ "ToQuantity","(" ]
                                       }, {
                                          "r" : "366",
                                          "s" : [ {
                                             "r" : "364",
                                             "s" : [ {
                                                "value" : [ "choice" ]
                                             } ]
                                          }, {
                                             "value" : [ " as " ]
                                          }, {
                                             "r" : "365",
                                             "s" : [ {
                                                "value" : [ "FHIR",".","Age" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ",\r\n\t\t\t  " ]
                              }, {
                                 "r" : "380",
                                 "s" : [ {
                                    "r" : "378",
                                    "s" : [ {
                                       "r" : "372",
                                       "s" : [ {
                                          "r" : "369",
                                          "s" : [ {
                                             "value" : [ "FHIRHelpers" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "372",
                                          "s" : [ {
                                             "value" : [ "ToDate","(" ]
                                          }, {
                                             "r" : "371",
                                             "s" : [ {
                                                "r" : "370",
                                                "s" : [ {
                                                   "value" : [ "Patient" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "371",
                                                "s" : [ {
                                                   "value" : [ "birthDate" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "377",
                                       "s" : [ {
                                          "r" : "373",
                                          "s" : [ {
                                             "value" : [ "FHIRHelpers" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "377",
                                          "s" : [ {
                                             "value" : [ "ToQuantity","(" ]
                                          }, {
                                             "r" : "376",
                                             "s" : [ {
                                                "r" : "374",
                                                "s" : [ {
                                                   "value" : [ "choice" ]
                                                } ]
                                             }, {
                                                "value" : [ " as " ]
                                             }, {
                                                "r" : "375",
                                                "s" : [ {
                                                   "value" : [ "FHIR",".","Age" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "379",
                                    "s" : [ {
                                       "value" : [ "1 ","year" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "411",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "385",
                              "s" : [ {
                                 "r" : "383",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "384",
                                 "s" : [ {
                                    "value" : [ "FHIR",".","Range" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\r\n\t\t  " ]
                           }, {
                              "r" : "410",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "396",
                                 "s" : [ {
                                    "r" : "389",
                                    "s" : [ {
                                       "r" : "386",
                                       "s" : [ {
                                          "value" : [ "FHIRHelpers" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "389",
                                       "s" : [ {
                                          "value" : [ "ToDate","(" ]
                                       }, {
                                          "r" : "388",
                                          "s" : [ {
                                             "r" : "387",
                                             "s" : [ {
                                                "value" : [ "Patient" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "388",
                                             "s" : [ {
                                                "value" : [ "birthDate" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "395",
                                    "s" : [ {
                                       "r" : "390",
                                       "s" : [ {
                                          "value" : [ "FHIRHelpers" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "395",
                                       "s" : [ {
                                          "value" : [ "ToQuantity","(" ]
                                       }, {
                                          "r" : "394",
                                          "s" : [ {
                                             "r" : "393",
                                             "s" : [ {
                                                "value" : [ "(" ]
                                             }, {
                                                "r" : "393",
                                                "s" : [ {
                                                   "r" : "391",
                                                   "s" : [ {
                                                      "value" : [ "choice" ]
                                                   } ]
                                                }, {
                                                   "value" : [ " as " ]
                                                }, {
                                                   "r" : "392",
                                                   "s" : [ {
                                                      "value" : [ "FHIR",".","Range" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ ")" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "394",
                                             "s" : [ {
                                                "value" : [ "low" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ",\r\n\t\t\t  " ]
                              }, {
                                 "r" : "409",
                                 "s" : [ {
                                    "r" : "407",
                                    "s" : [ {
                                       "r" : "400",
                                       "s" : [ {
                                          "r" : "397",
                                          "s" : [ {
                                             "value" : [ "FHIRHelpers" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "400",
                                          "s" : [ {
                                             "value" : [ "ToDate","(" ]
                                          }, {
                                             "r" : "399",
                                             "s" : [ {
                                                "r" : "398",
                                                "s" : [ {
                                                   "value" : [ "Patient" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "399",
                                                "s" : [ {
                                                   "value" : [ "birthDate" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "406",
                                       "s" : [ {
                                          "r" : "401",
                                          "s" : [ {
                                             "value" : [ "FHIRHelpers" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "406",
                                          "s" : [ {
                                             "value" : [ "ToQuantity","(" ]
                                          }, {
                                             "r" : "405",
                                             "s" : [ {
                                                "r" : "404",
                                                "s" : [ {
                                                   "value" : [ "(" ]
                                                }, {
                                                   "r" : "404",
                                                   "s" : [ {
                                                      "r" : "402",
                                                      "s" : [ {
                                                         "value" : [ "choice" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " as " ]
                                                   }, {
                                                      "r" : "403",
                                                      "s" : [ {
                                                         "value" : [ "FHIR",".","Range" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "405",
                                                "s" : [ {
                                                   "value" : [ "high" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "408",
                                    "s" : [ {
                                       "value" : [ "1 ","year" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "424",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "414",
                              "s" : [ {
                                 "r" : "412",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "413",
                                 "s" : [ {
                                    "value" : [ "FHIR",".","Timing" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\r\n\t\t  " ]
                           }, {
                              "r" : "423",
                              "s" : [ {
                                 "value" : [ "Message","(" ]
                              }, {
                                 "r" : "418",
                                 "s" : [ {
                                    "r" : "415",
                                    "value" : [ "null"," as " ]
                                 }, {
                                    "r" : "417",
                                    "s" : [ {
                                       "value" : [ "Interval<" ]
                                    }, {
                                       "r" : "416",
                                       "s" : [ {
                                          "value" : [ "DateTime" ]
                                       } ]
                                    }, {
                                       "value" : [ ">" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "419",
                                 "value" : [ ", ","true",", " ]
                              }, {
                                 "r" : "420",
                                 "s" : [ {
                                    "value" : [ "'1'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "421",
                                 "s" : [ {
                                    "value" : [ "'Error'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "422",
                                 "s" : [ {
                                    "value" : [ "'Cannot compute a single interval from a Timing type'" ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n    " ]
                        }, {
                           "r" : "437",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "427",
                              "s" : [ {
                                 "r" : "425",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "426",
                                 "s" : [ {
                                    "value" : [ "FHIR",".","string" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\r\n      " ]
                           }, {
                              "r" : "436",
                              "s" : [ {
                                 "value" : [ "Message","(" ]
                              }, {
                                 "r" : "431",
                                 "s" : [ {
                                    "r" : "428",
                                    "value" : [ "null"," as " ]
                                 }, {
                                    "r" : "430",
                                    "s" : [ {
                                       "value" : [ "Interval<" ]
                                    }, {
                                       "r" : "429",
                                       "s" : [ {
                                          "value" : [ "DateTime" ]
                                       } ]
                                    }, {
                                       "value" : [ ">" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "432",
                                 "value" : [ ", ","true",", " ]
                              }, {
                                 "r" : "433",
                                 "s" : [ {
                                    "value" : [ "'1'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "434",
                                 "s" : [ {
                                    "value" : [ "'Error'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "435",
                                 "s" : [ {
                                    "value" : [ "'Cannot compute an interval from a String value'" ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\telse\r\n\t\t\t" ]
                        }, {
                           "r" : "441",
                           "s" : [ {
                              "r" : "438",
                              "value" : [ "null"," as " ]
                           }, {
                              "r" : "440",
                              "s" : [ {
                                 "value" : [ "Interval<" ]
                              }, {
                                 "r" : "439",
                                 "s" : [ {
                                    "value" : [ "DateTime" ]
                                 } ]
                              }, {
                                 "value" : [ ">" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\tend" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "442",
               "locator" : "172:3-191:4",
               "type" : "Case",
               "caseItem" : [ {
                  "localId" : "331",
                  "locator" : "173:4-174:111",
                  "when" : {
                     "localId" : "319",
                     "locator" : "173:9-173:31",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "317",
                        "locator" : "173:9-173:14",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "318",
                        "locator" : "173:19-173:31",
                        "name" : "{http://hl7.org/fhir}dateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "localId" : "330",
                     "locator" : "174:6-174:111",
                     "lowClosed" : true,
                     "highClosed" : true,
                     "type" : "Interval",
                     "low" : {
                        "localId" : "324",
                        "locator" : "174:15-174:61",
                        "name" : "ToDateTime",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "323",
                           "locator" : "174:38-174:60",
                           "strict" : false,
                           "type" : "As",
                           "operand" : {
                              "localId" : "321",
                              "locator" : "174:38-174:43",
                              "name" : "choice",
                              "type" : "OperandRef"
                           },
                           "asTypeSpecifier" : {
                              "localId" : "322",
                              "locator" : "174:48-174:60",
                              "name" : "{http://hl7.org/fhir}dateTime",
                              "type" : "NamedTypeSpecifier"
                           }
                        } ]
                     },
                     "high" : {
                        "localId" : "329",
                        "locator" : "174:64-174:110",
                        "name" : "ToDateTime",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "328",
                           "locator" : "174:87-174:109",
                           "strict" : false,
                           "type" : "As",
                           "operand" : {
                              "localId" : "326",
                              "locator" : "174:87-174:92",
                              "name" : "choice",
                              "type" : "OperandRef"
                           },
                           "asTypeSpecifier" : {
                              "localId" : "327",
                              "locator" : "174:97-174:109",
                              "name" : "{http://hl7.org/fhir}dateTime",
                              "type" : "NamedTypeSpecifier"
                           }
                        } ]
                     }
                  }
               }, {
                  "localId" : "340",
                  "locator" : "175:3-176:49",
                  "when" : {
                     "localId" : "334",
                     "locator" : "175:8-175:28",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "332",
                        "locator" : "175:8-175:13",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "333",
                        "locator" : "175:18-175:28",
                        "name" : "{http://hl7.org/fhir}Period",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "localId" : "339",
                     "locator" : "176:5-176:49",
                     "name" : "ToInterval",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "338",
                        "locator" : "176:28-176:48",
                        "strict" : false,
                        "type" : "As",
                        "operand" : {
                           "localId" : "336",
                           "locator" : "176:28-176:33",
                           "name" : "choice",
                           "type" : "OperandRef"
                        },
                        "asTypeSpecifier" : {
                           "localId" : "337",
                           "locator" : "176:38-176:48",
                           "name" : "{http://hl7.org/fhir}Period",
                           "type" : "NamedTypeSpecifier"
                        }
                     } ]
                  }
               }, {
                  "localId" : "355",
                  "locator" : "177:3-178:107",
                  "when" : {
                     "localId" : "343",
                     "locator" : "177:8-177:29",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "341",
                        "locator" : "177:8-177:13",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "342",
                        "locator" : "177:18-177:29",
                        "name" : "{http://hl7.org/fhir}instant",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "localId" : "354",
                     "locator" : "178:4-178:107",
                     "lowClosed" : true,
                     "highClosed" : true,
                     "type" : "Interval",
                     "low" : {
                        "localId" : "348",
                        "locator" : "178:13-178:58",
                        "name" : "ToDateTime",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "347",
                           "locator" : "178:36-178:57",
                           "strict" : false,
                           "type" : "As",
                           "operand" : {
                              "localId" : "345",
                              "locator" : "178:36-178:41",
                              "name" : "choice",
                              "type" : "OperandRef"
                           },
                           "asTypeSpecifier" : {
                              "localId" : "346",
                              "locator" : "178:46-178:57",
                              "name" : "{http://hl7.org/fhir}instant",
                              "type" : "NamedTypeSpecifier"
                           }
                        } ]
                     },
                     "high" : {
                        "localId" : "353",
                        "locator" : "178:61-178:106",
                        "name" : "ToDateTime",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "352",
                           "locator" : "178:84-178:105",
                           "strict" : false,
                           "type" : "As",
                           "operand" : {
                              "localId" : "350",
                              "locator" : "178:84-178:89",
                              "name" : "choice",
                              "type" : "OperandRef"
                           },
                           "asTypeSpecifier" : {
                              "localId" : "351",
                              "locator" : "178:94-178:105",
                              "name" : "{http://hl7.org/fhir}instant",
                              "type" : "NamedTypeSpecifier"
                           }
                        } ]
                     }
                  }
               }, {
                  "localId" : "382",
                  "locator" : "179:3-181:97",
                  "when" : {
                     "localId" : "358",
                     "locator" : "179:8-179:25",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "356",
                        "locator" : "179:8-179:13",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "357",
                        "locator" : "179:18-179:25",
                        "name" : "{http://hl7.org/fhir}Age",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "type" : "Interval",
                     "low" : {
                        "type" : "ToDateTime",
                        "operand" : {
                           "path" : "low",
                           "type" : "Property",
                           "source" : {
                              "localId" : "381",
                              "locator" : "180:5-181:97",
                              "lowClosed" : true,
                              "highClosed" : false,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "368",
                                 "locator" : "180:14-180:95",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "362",
                                    "locator" : "180:14-180:50",
                                    "name" : "ToDate",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "361",
                                       "locator" : "180:33-180:49",
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "360",
                                          "locator" : "180:33-180:39",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "367",
                                    "locator" : "180:54-180:95",
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "366",
                                       "locator" : "180:77-180:94",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "364",
                                          "locator" : "180:77-180:82",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "365",
                                          "locator" : "180:87-180:94",
                                          "name" : "{http://hl7.org/fhir}Age",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              },
                              "high" : {
                                 "localId" : "380",
                                 "locator" : "181:6-181:96",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "378",
                                    "locator" : "181:6-181:87",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "372",
                                       "locator" : "181:6-181:42",
                                       "name" : "ToDate",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "371",
                                          "locator" : "181:25-181:41",
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "370",
                                             "locator" : "181:25-181:31",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "377",
                                       "locator" : "181:46-181:87",
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "376",
                                          "locator" : "181:69-181:86",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "374",
                                             "locator" : "181:69-181:74",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "375",
                                             "locator" : "181:79-181:86",
                                             "name" : "{http://hl7.org/fhir}Age",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "379",
                                    "locator" : "181:91-181:96",
                                    "value" : 1,
                                    "unit" : "year",
                                    "type" : "Quantity"
                                 } ]
                              }
                           }
                        }
                     },
                     "lowClosedExpression" : {
                        "path" : "lowClosed",
                        "type" : "Property",
                        "source" : {
                           "localId" : "381",
                           "locator" : "180:5-181:97",
                           "lowClosed" : true,
                           "highClosed" : false,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "368",
                              "locator" : "180:14-180:95",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "362",
                                 "locator" : "180:14-180:50",
                                 "name" : "ToDate",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "361",
                                    "locator" : "180:33-180:49",
                                    "path" : "birthDate",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "360",
                                       "locator" : "180:33-180:39",
                                       "name" : "Patient",
                                       "type" : "ExpressionRef"
                                    }
                                 } ]
                              }, {
                                 "localId" : "367",
                                 "locator" : "180:54-180:95",
                                 "name" : "ToQuantity",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "366",
                                    "locator" : "180:77-180:94",
                                    "strict" : false,
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "364",
                                       "locator" : "180:77-180:82",
                                       "name" : "choice",
                                       "type" : "OperandRef"
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "365",
                                       "locator" : "180:87-180:94",
                                       "name" : "{http://hl7.org/fhir}Age",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 } ]
                              } ]
                           },
                           "high" : {
                              "localId" : "380",
                              "locator" : "181:6-181:96",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "378",
                                 "locator" : "181:6-181:87",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "372",
                                    "locator" : "181:6-181:42",
                                    "name" : "ToDate",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "371",
                                       "locator" : "181:25-181:41",
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "370",
                                          "locator" : "181:25-181:31",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "377",
                                    "locator" : "181:46-181:87",
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "376",
                                       "locator" : "181:69-181:86",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "374",
                                          "locator" : "181:69-181:74",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "375",
                                          "locator" : "181:79-181:86",
                                          "name" : "{http://hl7.org/fhir}Age",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              }, {
                                 "localId" : "379",
                                 "locator" : "181:91-181:96",
                                 "value" : 1,
                                 "unit" : "year",
                                 "type" : "Quantity"
                              } ]
                           }
                        }
                     },
                     "high" : {
                        "type" : "ToDateTime",
                        "operand" : {
                           "path" : "high",
                           "type" : "Property",
                           "source" : {
                              "localId" : "381",
                              "locator" : "180:5-181:97",
                              "lowClosed" : true,
                              "highClosed" : false,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "368",
                                 "locator" : "180:14-180:95",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "362",
                                    "locator" : "180:14-180:50",
                                    "name" : "ToDate",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "361",
                                       "locator" : "180:33-180:49",
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "360",
                                          "locator" : "180:33-180:39",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "367",
                                    "locator" : "180:54-180:95",
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "366",
                                       "locator" : "180:77-180:94",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "364",
                                          "locator" : "180:77-180:82",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "365",
                                          "locator" : "180:87-180:94",
                                          "name" : "{http://hl7.org/fhir}Age",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              },
                              "high" : {
                                 "localId" : "380",
                                 "locator" : "181:6-181:96",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "378",
                                    "locator" : "181:6-181:87",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "372",
                                       "locator" : "181:6-181:42",
                                       "name" : "ToDate",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "371",
                                          "locator" : "181:25-181:41",
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "370",
                                             "locator" : "181:25-181:31",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "377",
                                       "locator" : "181:46-181:87",
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "376",
                                          "locator" : "181:69-181:86",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "374",
                                             "locator" : "181:69-181:74",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "375",
                                             "locator" : "181:79-181:86",
                                             "name" : "{http://hl7.org/fhir}Age",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "379",
                                    "locator" : "181:91-181:96",
                                    "value" : 1,
                                    "unit" : "year",
                                    "type" : "Quantity"
                                 } ]
                              }
                           }
                        }
                     },
                     "highClosedExpression" : {
                        "path" : "highClosed",
                        "type" : "Property",
                        "source" : {
                           "localId" : "381",
                           "locator" : "180:5-181:97",
                           "lowClosed" : true,
                           "highClosed" : false,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "368",
                              "locator" : "180:14-180:95",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "362",
                                 "locator" : "180:14-180:50",
                                 "name" : "ToDate",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "361",
                                    "locator" : "180:33-180:49",
                                    "path" : "birthDate",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "360",
                                       "locator" : "180:33-180:39",
                                       "name" : "Patient",
                                       "type" : "ExpressionRef"
                                    }
                                 } ]
                              }, {
                                 "localId" : "367",
                                 "locator" : "180:54-180:95",
                                 "name" : "ToQuantity",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "366",
                                    "locator" : "180:77-180:94",
                                    "strict" : false,
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "364",
                                       "locator" : "180:77-180:82",
                                       "name" : "choice",
                                       "type" : "OperandRef"
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "365",
                                       "locator" : "180:87-180:94",
                                       "name" : "{http://hl7.org/fhir}Age",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 } ]
                              } ]
                           },
                           "high" : {
                              "localId" : "380",
                              "locator" : "181:6-181:96",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "378",
                                 "locator" : "181:6-181:87",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "372",
                                    "locator" : "181:6-181:42",
                                    "name" : "ToDate",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "371",
                                       "locator" : "181:25-181:41",
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "370",
                                          "locator" : "181:25-181:31",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "377",
                                    "locator" : "181:46-181:87",
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "376",
                                       "locator" : "181:69-181:86",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "374",
                                          "locator" : "181:69-181:74",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "375",
                                          "locator" : "181:79-181:86",
                                          "name" : "{http://hl7.org/fhir}Age",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              }, {
                                 "localId" : "379",
                                 "locator" : "181:91-181:96",
                                 "value" : 1,
                                 "unit" : "year",
                                 "type" : "Quantity"
                              } ]
                           }
                        }
                     }
                  }
               }, {
                  "localId" : "411",
                  "locator" : "182:3-184:106",
                  "when" : {
                     "localId" : "385",
                     "locator" : "182:8-182:27",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "383",
                        "locator" : "182:8-182:13",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "384",
                        "locator" : "182:18-182:27",
                        "name" : "{http://hl7.org/fhir}Range",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "type" : "Interval",
                     "low" : {
                        "type" : "ToDateTime",
                        "operand" : {
                           "path" : "low",
                           "type" : "Property",
                           "source" : {
                              "localId" : "410",
                              "locator" : "183:5-184:106",
                              "lowClosed" : true,
                              "highClosed" : false,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "396",
                                 "locator" : "183:14-183:103",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "389",
                                    "locator" : "183:14-183:50",
                                    "name" : "ToDate",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "388",
                                       "locator" : "183:33-183:49",
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "387",
                                          "locator" : "183:33-183:39",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "395",
                                    "locator" : "183:54-183:103",
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "394",
                                       "locator" : "183:77-183:102",
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "393",
                                          "locator" : "183:77-183:98",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "391",
                                             "locator" : "183:78-183:83",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "392",
                                             "locator" : "183:88-183:97",
                                             "name" : "{http://hl7.org/fhir}Range",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    } ]
                                 } ]
                              },
                              "high" : {
                                 "localId" : "409",
                                 "locator" : "184:6-184:105",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "407",
                                    "locator" : "184:6-184:96",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "400",
                                       "locator" : "184:6-184:42",
                                       "name" : "ToDate",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "399",
                                          "locator" : "184:25-184:41",
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "398",
                                             "locator" : "184:25-184:31",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "406",
                                       "locator" : "184:46-184:96",
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "405",
                                          "locator" : "184:69-184:95",
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "404",
                                             "locator" : "184:69-184:90",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "402",
                                                "locator" : "184:70-184:75",
                                                "name" : "choice",
                                                "type" : "OperandRef"
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "403",
                                                "locator" : "184:80-184:89",
                                                "name" : "{http://hl7.org/fhir}Range",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "408",
                                    "locator" : "184:100-184:105",
                                    "value" : 1,
                                    "unit" : "year",
                                    "type" : "Quantity"
                                 } ]
                              }
                           }
                        }
                     },
                     "lowClosedExpression" : {
                        "path" : "lowClosed",
                        "type" : "Property",
                        "source" : {
                           "localId" : "410",
                           "locator" : "183:5-184:106",
                           "lowClosed" : true,
                           "highClosed" : false,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "396",
                              "locator" : "183:14-183:103",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "389",
                                 "locator" : "183:14-183:50",
                                 "name" : "ToDate",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "388",
                                    "locator" : "183:33-183:49",
                                    "path" : "birthDate",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "387",
                                       "locator" : "183:33-183:39",
                                       "name" : "Patient",
                                       "type" : "ExpressionRef"
                                    }
                                 } ]
                              }, {
                                 "localId" : "395",
                                 "locator" : "183:54-183:103",
                                 "name" : "ToQuantity",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "394",
                                    "locator" : "183:77-183:102",
                                    "path" : "low",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "393",
                                       "locator" : "183:77-183:98",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "391",
                                          "locator" : "183:78-183:83",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "392",
                                          "locator" : "183:88-183:97",
                                          "name" : "{http://hl7.org/fhir}Range",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 } ]
                              } ]
                           },
                           "high" : {
                              "localId" : "409",
                              "locator" : "184:6-184:105",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "407",
                                 "locator" : "184:6-184:96",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "400",
                                    "locator" : "184:6-184:42",
                                    "name" : "ToDate",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "399",
                                       "locator" : "184:25-184:41",
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "398",
                                          "locator" : "184:25-184:31",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "406",
                                    "locator" : "184:46-184:96",
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "405",
                                       "locator" : "184:69-184:95",
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "404",
                                          "locator" : "184:69-184:90",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "402",
                                             "locator" : "184:70-184:75",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "403",
                                             "locator" : "184:80-184:89",
                                             "name" : "{http://hl7.org/fhir}Range",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    } ]
                                 } ]
                              }, {
                                 "localId" : "408",
                                 "locator" : "184:100-184:105",
                                 "value" : 1,
                                 "unit" : "year",
                                 "type" : "Quantity"
                              } ]
                           }
                        }
                     },
                     "high" : {
                        "type" : "ToDateTime",
                        "operand" : {
                           "path" : "high",
                           "type" : "Property",
                           "source" : {
                              "localId" : "410",
                              "locator" : "183:5-184:106",
                              "lowClosed" : true,
                              "highClosed" : false,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "396",
                                 "locator" : "183:14-183:103",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "389",
                                    "locator" : "183:14-183:50",
                                    "name" : "ToDate",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "388",
                                       "locator" : "183:33-183:49",
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "387",
                                          "locator" : "183:33-183:39",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "395",
                                    "locator" : "183:54-183:103",
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "394",
                                       "locator" : "183:77-183:102",
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "393",
                                          "locator" : "183:77-183:98",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "391",
                                             "locator" : "183:78-183:83",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "392",
                                             "locator" : "183:88-183:97",
                                             "name" : "{http://hl7.org/fhir}Range",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    } ]
                                 } ]
                              },
                              "high" : {
                                 "localId" : "409",
                                 "locator" : "184:6-184:105",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "407",
                                    "locator" : "184:6-184:96",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "400",
                                       "locator" : "184:6-184:42",
                                       "name" : "ToDate",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "399",
                                          "locator" : "184:25-184:41",
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "398",
                                             "locator" : "184:25-184:31",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "406",
                                       "locator" : "184:46-184:96",
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "405",
                                          "locator" : "184:69-184:95",
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "404",
                                             "locator" : "184:69-184:90",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "402",
                                                "locator" : "184:70-184:75",
                                                "name" : "choice",
                                                "type" : "OperandRef"
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "403",
                                                "locator" : "184:80-184:89",
                                                "name" : "{http://hl7.org/fhir}Range",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "408",
                                    "locator" : "184:100-184:105",
                                    "value" : 1,
                                    "unit" : "year",
                                    "type" : "Quantity"
                                 } ]
                              }
                           }
                        }
                     },
                     "highClosedExpression" : {
                        "path" : "highClosed",
                        "type" : "Property",
                        "source" : {
                           "localId" : "410",
                           "locator" : "183:5-184:106",
                           "lowClosed" : true,
                           "highClosed" : false,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "396",
                              "locator" : "183:14-183:103",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "389",
                                 "locator" : "183:14-183:50",
                                 "name" : "ToDate",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "388",
                                    "locator" : "183:33-183:49",
                                    "path" : "birthDate",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "387",
                                       "locator" : "183:33-183:39",
                                       "name" : "Patient",
                                       "type" : "ExpressionRef"
                                    }
                                 } ]
                              }, {
                                 "localId" : "395",
                                 "locator" : "183:54-183:103",
                                 "name" : "ToQuantity",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "394",
                                    "locator" : "183:77-183:102",
                                    "path" : "low",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "393",
                                       "locator" : "183:77-183:98",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "391",
                                          "locator" : "183:78-183:83",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "392",
                                          "locator" : "183:88-183:97",
                                          "name" : "{http://hl7.org/fhir}Range",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 } ]
                              } ]
                           },
                           "high" : {
                              "localId" : "409",
                              "locator" : "184:6-184:105",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "407",
                                 "locator" : "184:6-184:96",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "400",
                                    "locator" : "184:6-184:42",
                                    "name" : "ToDate",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "399",
                                       "locator" : "184:25-184:41",
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "398",
                                          "locator" : "184:25-184:31",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "406",
                                    "locator" : "184:46-184:96",
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "405",
                                       "locator" : "184:69-184:95",
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "404",
                                          "locator" : "184:69-184:90",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "402",
                                             "locator" : "184:70-184:75",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "403",
                                             "locator" : "184:80-184:89",
                                             "name" : "{http://hl7.org/fhir}Range",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    } ]
                                 } ]
                              }, {
                                 "localId" : "408",
                                 "locator" : "184:100-184:105",
                                 "value" : 1,
                                 "unit" : "year",
                                 "type" : "Quantity"
                              } ]
                           }
                        }
                     }
                  }
               }, {
                  "localId" : "424",
                  "locator" : "185:3-186:114",
                  "when" : {
                     "localId" : "414",
                     "locator" : "185:8-185:28",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "412",
                        "locator" : "185:8-185:13",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "413",
                        "locator" : "185:18-185:28",
                        "name" : "{http://hl7.org/fhir}Timing",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "localId" : "423",
                     "locator" : "186:5-186:114",
                     "type" : "Message",
                     "source" : {
                        "localId" : "418",
                        "locator" : "186:13-186:38",
                        "strict" : false,
                        "type" : "As",
                        "operand" : {
                           "localId" : "415",
                           "locator" : "186:13-186:16",
                           "type" : "Null"
                        },
                        "asTypeSpecifier" : {
                           "localId" : "417",
                           "locator" : "186:21-186:38",
                           "type" : "IntervalTypeSpecifier",
                           "pointType" : {
                              "localId" : "416",
                              "locator" : "186:30-186:37",
                              "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                              "type" : "NamedTypeSpecifier"
                           }
                        }
                     },
                     "condition" : {
                        "localId" : "419",
                        "locator" : "186:41-186:44",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Boolean",
                        "value" : "true",
                        "type" : "Literal"
                     },
                     "code" : {
                        "localId" : "420",
                        "locator" : "186:47-186:49",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "1",
                        "type" : "Literal"
                     },
                     "severity" : {
                        "localId" : "421",
                        "locator" : "186:52-186:58",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "Error",
                        "type" : "Literal"
                     },
                     "message" : {
                        "localId" : "422",
                        "locator" : "186:61-186:113",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "Cannot compute a single interval from a Timing type",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "437",
                  "locator" : "187:5-188:111",
                  "when" : {
                     "localId" : "427",
                     "locator" : "187:10-187:30",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "425",
                        "locator" : "187:10-187:15",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "426",
                        "locator" : "187:20-187:30",
                        "name" : "{http://hl7.org/fhir}string",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "localId" : "436",
                     "locator" : "188:7-188:111",
                     "type" : "Message",
                     "source" : {
                        "localId" : "431",
                        "locator" : "188:15-188:40",
                        "strict" : false,
                        "type" : "As",
                        "operand" : {
                           "localId" : "428",
                           "locator" : "188:15-188:18",
                           "type" : "Null"
                        },
                        "asTypeSpecifier" : {
                           "localId" : "430",
                           "locator" : "188:23-188:40",
                           "type" : "IntervalTypeSpecifier",
                           "pointType" : {
                              "localId" : "429",
                              "locator" : "188:32-188:39",
                              "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                              "type" : "NamedTypeSpecifier"
                           }
                        }
                     },
                     "condition" : {
                        "localId" : "432",
                        "locator" : "188:43-188:46",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Boolean",
                        "value" : "true",
                        "type" : "Literal"
                     },
                     "code" : {
                        "localId" : "433",
                        "locator" : "188:49-188:51",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "1",
                        "type" : "Literal"
                     },
                     "severity" : {
                        "localId" : "434",
                        "locator" : "188:54-188:60",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "Error",
                        "type" : "Literal"
                     },
                     "message" : {
                        "localId" : "435",
                        "locator" : "188:63-188:110",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "Cannot compute an interval from a String value",
                        "type" : "Literal"
                     }
                  }
               } ],
               "else" : {
                  "localId" : "441",
                  "locator" : "190:4-190:29",
                  "strict" : false,
                  "type" : "As",
                  "operand" : {
                     "localId" : "438",
                     "locator" : "190:4-190:7",
                     "type" : "Null"
                  },
                  "asTypeSpecifier" : {
                     "localId" : "440",
                     "locator" : "190:12-190:29",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "439",
                        "locator" : "190:21-190:28",
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "choice",
               "operandTypeSpecifier" : {
                  "localId" : "316",
                  "locator" : "171:45-171:140",
                  "type" : "ChoiceTypeSpecifier",
                  "choice" : [ {
                     "localId" : "309",
                     "locator" : "171:52-171:64",
                     "name" : "{http://hl7.org/fhir}dateTime",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "310",
                     "locator" : "171:67-171:77",
                     "name" : "{http://hl7.org/fhir}Period",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "311",
                     "locator" : "171:80-171:90",
                     "name" : "{http://hl7.org/fhir}Timing",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "312",
                     "locator" : "171:93-171:104",
                     "name" : "{http://hl7.org/fhir}instant",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "313",
                     "locator" : "171:107-171:117",
                     "name" : "{http://hl7.org/fhir}string",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "314",
                     "locator" : "171:120-171:127",
                     "name" : "{http://hl7.org/fhir}Age",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "315",
                     "locator" : "171:130-171:139",
                     "name" : "{http://hl7.org/fhir}Range",
                     "type" : "NamedTypeSpecifier"
                  } ]
               }
            } ]
         }, {
            "localId" : "563",
            "locator" : "193:1-208:10",
            "name" : "Normalize Abatement",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "563",
                  "s" : [ {
                     "value" : [ "define function ","\"Normalize Abatement\"","(","condition"," " ]
                  }, {
                     "r" : "444",
                     "s" : [ {
                        "value" : [ "Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "562",
                     "s" : [ {
                        "r" : "562",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "448",
                           "s" : [ {
                              "r" : "446",
                              "s" : [ {
                                 "r" : "445",
                                 "s" : [ {
                                    "value" : [ "condition" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "446",
                                 "s" : [ {
                                    "value" : [ "abatement" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " is " ]
                           }, {
                              "r" : "447",
                              "s" : [ {
                                 "value" : [ "FHIR",".","dateTime" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " then\r\n\t  " ]
                        }, {
                           "r" : "461",
                           "s" : [ {
                              "value" : [ "Interval[" ]
                           }, {
                              "r" : "454",
                              "s" : [ {
                                 "r" : "449",
                                 "s" : [ {
                                    "value" : [ "FHIRHelpers" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "454",
                                 "s" : [ {
                                    "value" : [ "ToDateTime","(" ]
                                 }, {
                                    "r" : "453",
                                    "s" : [ {
                                       "r" : "451",
                                       "s" : [ {
                                          "r" : "450",
                                          "s" : [ {
                                             "value" : [ "condition" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "451",
                                          "s" : [ {
                                             "value" : [ "abatement" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " as " ]
                                    }, {
                                       "r" : "452",
                                       "s" : [ {
                                          "value" : [ "FHIR",".","dateTime" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "460",
                              "s" : [ {
                                 "r" : "455",
                                 "s" : [ {
                                    "value" : [ "FHIRHelpers" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "460",
                                 "s" : [ {
                                    "value" : [ "ToDateTime","(" ]
                                 }, {
                                    "r" : "459",
                                    "s" : [ {
                                       "r" : "457",
                                       "s" : [ {
                                          "r" : "456",
                                          "s" : [ {
                                             "value" : [ "condition" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "457",
                                          "s" : [ {
                                             "value" : [ "abatement" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " as " ]
                                    }, {
                                       "r" : "458",
                                       "s" : [ {
                                          "value" : [ "FHIR",".","dateTime" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "]" ]
                           } ]
                        }, {
                           "value" : [ "\r\n\telse " ]
                        }, {
                           "r" : "561",
                           "s" : [ {
                              "value" : [ "if " ]
                           }, {
                              "r" : "465",
                              "s" : [ {
                                 "r" : "463",
                                 "s" : [ {
                                    "r" : "462",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "463",
                                    "s" : [ {
                                       "value" : [ "abatement" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "464",
                                 "s" : [ {
                                    "value" : [ "FHIR",".","Period" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\r\n\t  " ]
                           }, {
                              "r" : "471",
                              "s" : [ {
                                 "r" : "466",
                                 "s" : [ {
                                    "value" : [ "FHIRHelpers" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "471",
                                 "s" : [ {
                                    "value" : [ "ToInterval","(" ]
                                 }, {
                                    "r" : "470",
                                    "s" : [ {
                                       "r" : "468",
                                       "s" : [ {
                                          "r" : "467",
                                          "s" : [ {
                                             "value" : [ "condition" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "468",
                                          "s" : [ {
                                             "value" : [ "abatement" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " as " ]
                                    }, {
                                       "r" : "469",
                                       "s" : [ {
                                          "value" : [ "FHIR",".","Period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n\telse " ]
                           }, {
                              "r" : "560",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "475",
                                 "s" : [ {
                                    "r" : "473",
                                    "s" : [ {
                                       "r" : "472",
                                       "s" : [ {
                                          "value" : [ "condition" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "473",
                                       "s" : [ {
                                          "value" : [ "abatement" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " is " ]
                                 }, {
                                    "r" : "474",
                                    "s" : [ {
                                       "value" : [ "FHIR",".","string" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " then\r\n    " ]
                              }, {
                                 "r" : "484",
                                 "s" : [ {
                                    "value" : [ "Message","(" ]
                                 }, {
                                    "r" : "479",
                                    "s" : [ {
                                       "r" : "476",
                                       "value" : [ "null"," as " ]
                                    }, {
                                       "r" : "478",
                                       "s" : [ {
                                          "value" : [ "Interval<" ]
                                       }, {
                                          "r" : "477",
                                          "s" : [ {
                                             "value" : [ "DateTime" ]
                                          } ]
                                       }, {
                                          "value" : [ ">" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "480",
                                    "value" : [ ", ","true",", " ]
                                 }, {
                                    "r" : "481",
                                    "s" : [ {
                                       "value" : [ "'1'" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "482",
                                    "s" : [ {
                                       "value" : [ "'Error'" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "483",
                                    "s" : [ {
                                       "value" : [ "'Cannot compute an interval from a String value'" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n\telse " ]
                              }, {
                                 "r" : "559",
                                 "s" : [ {
                                    "value" : [ "if " ]
                                 }, {
                                    "r" : "488",
                                    "s" : [ {
                                       "r" : "486",
                                       "s" : [ {
                                          "r" : "485",
                                          "s" : [ {
                                             "value" : [ "condition" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "486",
                                          "s" : [ {
                                             "value" : [ "abatement" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " is " ]
                                    }, {
                                       "r" : "487",
                                       "s" : [ {
                                          "value" : [ "FHIR",".","Age" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " then\r\n\t\t" ]
                                 }, {
                                    "r" : "513",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "499",
                                       "s" : [ {
                                          "r" : "492",
                                          "s" : [ {
                                             "r" : "489",
                                             "s" : [ {
                                                "value" : [ "FHIRHelpers" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "492",
                                             "s" : [ {
                                                "value" : [ "ToDate","(" ]
                                             }, {
                                                "r" : "491",
                                                "s" : [ {
                                                   "r" : "490",
                                                   "s" : [ {
                                                      "value" : [ "Patient" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "491",
                                                   "s" : [ {
                                                      "value" : [ "birthDate" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ ")" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " + " ]
                                       }, {
                                          "r" : "498",
                                          "s" : [ {
                                             "r" : "493",
                                             "s" : [ {
                                                "value" : [ "FHIRHelpers" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "498",
                                             "s" : [ {
                                                "value" : [ "ToQuantity","(" ]
                                             }, {
                                                "r" : "497",
                                                "s" : [ {
                                                   "r" : "495",
                                                   "s" : [ {
                                                      "r" : "494",
                                                      "s" : [ {
                                                         "value" : [ "condition" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "495",
                                                      "s" : [ {
                                                         "value" : [ "abatement" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ " as " ]
                                                }, {
                                                   "r" : "496",
                                                   "s" : [ {
                                                      "value" : [ "FHIR",".","Age" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ ")" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ",\r\n\t\t\t" ]
                                    }, {
                                       "r" : "512",
                                       "s" : [ {
                                          "r" : "510",
                                          "s" : [ {
                                             "r" : "503",
                                             "s" : [ {
                                                "r" : "500",
                                                "s" : [ {
                                                   "value" : [ "FHIRHelpers" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "503",
                                                "s" : [ {
                                                   "value" : [ "ToDate","(" ]
                                                }, {
                                                   "r" : "502",
                                                   "s" : [ {
                                                      "r" : "501",
                                                      "s" : [ {
                                                         "value" : [ "Patient" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "502",
                                                      "s" : [ {
                                                         "value" : [ "birthDate" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " + " ]
                                          }, {
                                             "r" : "509",
                                             "s" : [ {
                                                "r" : "504",
                                                "s" : [ {
                                                   "value" : [ "FHIRHelpers" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "509",
                                                "s" : [ {
                                                   "value" : [ "ToQuantity","(" ]
                                                }, {
                                                   "r" : "508",
                                                   "s" : [ {
                                                      "r" : "506",
                                                      "s" : [ {
                                                         "r" : "505",
                                                         "s" : [ {
                                                            "value" : [ "condition" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "506",
                                                         "s" : [ {
                                                            "value" : [ "abatement" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " as " ]
                                                   }, {
                                                      "r" : "507",
                                                      "s" : [ {
                                                         "value" : [ "FHIR",".","Age" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " + " ]
                                       }, {
                                          "r" : "511",
                                          "s" : [ {
                                             "value" : [ "1 ","year" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ "\r\n\telse " ]
                                 }, {
                                    "r" : "558",
                                    "s" : [ {
                                       "value" : [ "if " ]
                                    }, {
                                       "r" : "517",
                                       "s" : [ {
                                          "r" : "515",
                                          "s" : [ {
                                             "r" : "514",
                                             "s" : [ {
                                                "value" : [ "condition" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "515",
                                             "s" : [ {
                                                "value" : [ "abatement" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " is " ]
                                       }, {
                                          "r" : "516",
                                          "s" : [ {
                                             "value" : [ "FHIR",".","Range" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " then\r\n\t  " ]
                                    }, {
                                       "r" : "544",
                                       "s" : [ {
                                          "value" : [ "Interval[" ]
                                       }, {
                                          "r" : "529",
                                          "s" : [ {
                                             "r" : "521",
                                             "s" : [ {
                                                "r" : "518",
                                                "s" : [ {
                                                   "value" : [ "FHIRHelpers" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "521",
                                                "s" : [ {
                                                   "value" : [ "ToDate","(" ]
                                                }, {
                                                   "r" : "520",
                                                   "s" : [ {
                                                      "r" : "519",
                                                      "s" : [ {
                                                         "value" : [ "Patient" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "520",
                                                      "s" : [ {
                                                         "value" : [ "birthDate" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " + " ]
                                          }, {
                                             "r" : "528",
                                             "s" : [ {
                                                "r" : "522",
                                                "s" : [ {
                                                   "value" : [ "FHIRHelpers" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "528",
                                                "s" : [ {
                                                   "value" : [ "ToQuantity","(" ]
                                                }, {
                                                   "r" : "527",
                                                   "s" : [ {
                                                      "r" : "526",
                                                      "s" : [ {
                                                         "value" : [ "(" ]
                                                      }, {
                                                         "r" : "526",
                                                         "s" : [ {
                                                            "r" : "524",
                                                            "s" : [ {
                                                               "r" : "523",
                                                               "s" : [ {
                                                                  "value" : [ "condition" ]
                                                               } ]
                                                            }, {
                                                               "value" : [ "." ]
                                                            }, {
                                                               "r" : "524",
                                                               "s" : [ {
                                                                  "value" : [ "abatement" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " as " ]
                                                         }, {
                                                            "r" : "525",
                                                            "s" : [ {
                                                               "value" : [ "FHIR",".","Range" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ ")" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "527",
                                                      "s" : [ {
                                                         "value" : [ "low" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ",\r\n\t\t  " ]
                                       }, {
                                          "r" : "543",
                                          "s" : [ {
                                             "r" : "541",
                                             "s" : [ {
                                                "r" : "533",
                                                "s" : [ {
                                                   "r" : "530",
                                                   "s" : [ {
                                                      "value" : [ "FHIRHelpers" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "533",
                                                   "s" : [ {
                                                      "value" : [ "ToDate","(" ]
                                                   }, {
                                                      "r" : "532",
                                                      "s" : [ {
                                                         "r" : "531",
                                                         "s" : [ {
                                                            "value" : [ "Patient" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "532",
                                                         "s" : [ {
                                                            "value" : [ "birthDate" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ ")" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " + " ]
                                             }, {
                                                "r" : "540",
                                                "s" : [ {
                                                   "r" : "534",
                                                   "s" : [ {
                                                      "value" : [ "FHIRHelpers" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "540",
                                                   "s" : [ {
                                                      "value" : [ "ToQuantity","(" ]
                                                   }, {
                                                      "r" : "539",
                                                      "s" : [ {
                                                         "r" : "538",
                                                         "s" : [ {
                                                            "value" : [ "(" ]
                                                         }, {
                                                            "r" : "538",
                                                            "s" : [ {
                                                               "r" : "536",
                                                               "s" : [ {
                                                                  "r" : "535",
                                                                  "s" : [ {
                                                                     "value" : [ "condition" ]
                                                                  } ]
                                                               }, {
                                                                  "value" : [ "." ]
                                                               }, {
                                                                  "r" : "536",
                                                                  "s" : [ {
                                                                     "value" : [ "abatement" ]
                                                                  } ]
                                                               } ]
                                                            }, {
                                                               "value" : [ " as " ]
                                                            }, {
                                                               "r" : "537",
                                                               "s" : [ {
                                                                  "value" : [ "FHIR",".","Range" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ ")" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "539",
                                                         "s" : [ {
                                                            "value" : [ "high" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ ")" ]
                                                   } ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " + " ]
                                          }, {
                                             "r" : "542",
                                             "s" : [ {
                                                "value" : [ "1 ","year" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n\telse " ]
                                    }, {
                                       "r" : "557",
                                       "s" : [ {
                                          "value" : [ "if " ]
                                       }, {
                                          "r" : "548",
                                          "s" : [ {
                                             "r" : "546",
                                             "s" : [ {
                                                "r" : "545",
                                                "s" : [ {
                                                   "value" : [ "condition" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "546",
                                                "s" : [ {
                                                   "value" : [ "abatement" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " is " ]
                                          }, {
                                             "r" : "547",
                                             "s" : [ {
                                                "value" : [ "FHIR",".","boolean" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " then\r\n\t  " ]
                                       }, {
                                          "r" : "555",
                                          "s" : [ {
                                             "value" : [ "Interval[" ]
                                          }, {
                                             "r" : "552",
                                             "s" : [ {
                                                "value" : [ "end of " ]
                                             }, {
                                                "r" : "551",
                                                "s" : [ {
                                                   "value" : [ "\"Normalize Interval\"","(" ]
                                                }, {
                                                   "r" : "550",
                                                   "s" : [ {
                                                      "r" : "549",
                                                      "s" : [ {
                                                         "value" : [ "condition" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "550",
                                                      "s" : [ {
                                                         "value" : [ "onset" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ", " ]
                                          }, {
                                             "r" : "554",
                                             "s" : [ {
                                                "r" : "553",
                                                "s" : [ {
                                                   "value" : [ "condition" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "554",
                                                "s" : [ {
                                                   "value" : [ "recordedDate" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       }, {
                                          "r" : "556",
                                          "value" : [ "\r\n\telse ","null" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "562",
               "locator" : "194:2-208:10",
               "type" : "If",
               "condition" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                  "type" : "As",
                  "operand" : {
                     "localId" : "448",
                     "locator" : "194:5-194:40",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "446",
                        "locator" : "194:5-194:23",
                        "path" : "abatement",
                        "type" : "Property",
                        "source" : {
                           "localId" : "445",
                           "locator" : "194:5-194:13",
                           "name" : "condition",
                           "type" : "OperandRef"
                        }
                     },
                     "isTypeSpecifier" : {
                        "localId" : "447",
                        "locator" : "194:28-194:40",
                        "name" : "{http://hl7.org/fhir}dateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               },
               "then" : {
                  "localId" : "461",
                  "locator" : "195:4-195:135",
                  "lowClosed" : true,
                  "highClosed" : true,
                  "type" : "Interval",
                  "low" : {
                     "localId" : "454",
                     "locator" : "195:13-195:72",
                     "name" : "ToDateTime",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "453",
                        "locator" : "195:36-195:71",
                        "strict" : false,
                        "type" : "As",
                        "operand" : {
                           "localId" : "451",
                           "locator" : "195:36-195:54",
                           "path" : "abatement",
                           "type" : "Property",
                           "source" : {
                              "localId" : "450",
                              "locator" : "195:36-195:44",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        },
                        "asTypeSpecifier" : {
                           "localId" : "452",
                           "locator" : "195:59-195:71",
                           "name" : "{http://hl7.org/fhir}dateTime",
                           "type" : "NamedTypeSpecifier"
                        }
                     } ]
                  },
                  "high" : {
                     "localId" : "460",
                     "locator" : "195:75-195:134",
                     "name" : "ToDateTime",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "459",
                        "locator" : "195:98-195:133",
                        "strict" : false,
                        "type" : "As",
                        "operand" : {
                           "localId" : "457",
                           "locator" : "195:98-195:116",
                           "path" : "abatement",
                           "type" : "Property",
                           "source" : {
                              "localId" : "456",
                              "locator" : "195:98-195:106",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        },
                        "asTypeSpecifier" : {
                           "localId" : "458",
                           "locator" : "195:121-195:133",
                           "name" : "{http://hl7.org/fhir}dateTime",
                           "type" : "NamedTypeSpecifier"
                        }
                     } ]
                  }
               },
               "else" : {
                  "localId" : "561",
                  "locator" : "196:7-208:10",
                  "type" : "If",
                  "condition" : {
                     "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                     "type" : "As",
                     "operand" : {
                        "localId" : "465",
                        "locator" : "196:10-196:43",
                        "type" : "Is",
                        "operand" : {
                           "localId" : "463",
                           "locator" : "196:10-196:28",
                           "path" : "abatement",
                           "type" : "Property",
                           "source" : {
                              "localId" : "462",
                              "locator" : "196:10-196:18",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        },
                        "isTypeSpecifier" : {
                           "localId" : "464",
                           "locator" : "196:33-196:43",
                           "name" : "{http://hl7.org/fhir}Period",
                           "type" : "NamedTypeSpecifier"
                        }
                     }
                  },
                  "then" : {
                     "localId" : "471",
                     "locator" : "197:4-197:61",
                     "name" : "ToInterval",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "470",
                        "locator" : "197:27-197:60",
                        "strict" : false,
                        "type" : "As",
                        "operand" : {
                           "localId" : "468",
                           "locator" : "197:27-197:45",
                           "path" : "abatement",
                           "type" : "Property",
                           "source" : {
                              "localId" : "467",
                              "locator" : "197:27-197:35",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        },
                        "asTypeSpecifier" : {
                           "localId" : "469",
                           "locator" : "197:50-197:60",
                           "name" : "{http://hl7.org/fhir}Period",
                           "type" : "NamedTypeSpecifier"
                        }
                     } ]
                  },
                  "else" : {
                     "localId" : "560",
                     "locator" : "198:7-208:10",
                     "type" : "If",
                     "condition" : {
                        "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                        "type" : "As",
                        "operand" : {
                           "localId" : "475",
                           "locator" : "198:10-198:43",
                           "type" : "Is",
                           "operand" : {
                              "localId" : "473",
                              "locator" : "198:10-198:28",
                              "path" : "abatement",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "472",
                                 "locator" : "198:10-198:18",
                                 "name" : "condition",
                                 "type" : "OperandRef"
                              }
                           },
                           "isTypeSpecifier" : {
                              "localId" : "474",
                              "locator" : "198:33-198:43",
                              "name" : "{http://hl7.org/fhir}string",
                              "type" : "NamedTypeSpecifier"
                           }
                        }
                     },
                     "then" : {
                        "localId" : "484",
                        "locator" : "199:5-199:109",
                        "type" : "Message",
                        "source" : {
                           "localId" : "479",
                           "locator" : "199:13-199:38",
                           "strict" : false,
                           "type" : "As",
                           "operand" : {
                              "localId" : "476",
                              "locator" : "199:13-199:16",
                              "type" : "Null"
                           },
                           "asTypeSpecifier" : {
                              "localId" : "478",
                              "locator" : "199:21-199:38",
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "localId" : "477",
                                 "locator" : "199:30-199:37",
                                 "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }
                        },
                        "condition" : {
                           "localId" : "480",
                           "locator" : "199:41-199:44",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Boolean",
                           "value" : "true",
                           "type" : "Literal"
                        },
                        "code" : {
                           "localId" : "481",
                           "locator" : "199:47-199:49",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "1",
                           "type" : "Literal"
                        },
                        "severity" : {
                           "localId" : "482",
                           "locator" : "199:52-199:58",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "Error",
                           "type" : "Literal"
                        },
                        "message" : {
                           "localId" : "483",
                           "locator" : "199:61-199:108",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "Cannot compute an interval from a String value",
                           "type" : "Literal"
                        }
                     },
                     "else" : {
                        "localId" : "559",
                        "locator" : "200:7-208:10",
                        "type" : "If",
                        "condition" : {
                           "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                           "type" : "As",
                           "operand" : {
                              "localId" : "488",
                              "locator" : "200:10-200:40",
                              "type" : "Is",
                              "operand" : {
                                 "localId" : "486",
                                 "locator" : "200:10-200:28",
                                 "path" : "abatement",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "485",
                                    "locator" : "200:10-200:18",
                                    "name" : "condition",
                                    "type" : "OperandRef"
                                 }
                              },
                              "isTypeSpecifier" : {
                                 "localId" : "487",
                                 "locator" : "200:33-200:40",
                                 "name" : "{http://hl7.org/fhir}Age",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }
                        },
                        "then" : {
                           "type" : "Interval",
                           "low" : {
                              "type" : "ToDateTime",
                              "operand" : {
                                 "path" : "low",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "513",
                                    "locator" : "201:3-202:108",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "499",
                                       "locator" : "201:12-201:106",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "492",
                                          "locator" : "201:12-201:48",
                                          "name" : "ToDate",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "491",
                                             "locator" : "201:31-201:47",
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "490",
                                                "locator" : "201:31-201:37",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "498",
                                          "locator" : "201:52-201:106",
                                          "name" : "ToQuantity",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "497",
                                             "locator" : "201:75-201:105",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "495",
                                                "locator" : "201:75-201:93",
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "494",
                                                   "locator" : "201:75-201:83",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "496",
                                                "locator" : "201:98-201:105",
                                                "name" : "{http://hl7.org/fhir}Age",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "512",
                                       "locator" : "202:4-202:107",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "510",
                                          "locator" : "202:4-202:98",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "503",
                                             "locator" : "202:4-202:40",
                                             "name" : "ToDate",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "502",
                                                "locator" : "202:23-202:39",
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "501",
                                                   "locator" : "202:23-202:29",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "509",
                                             "locator" : "202:44-202:98",
                                             "name" : "ToQuantity",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "508",
                                                "locator" : "202:67-202:97",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "506",
                                                   "locator" : "202:67-202:85",
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "505",
                                                      "locator" : "202:67-202:75",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "507",
                                                   "locator" : "202:90-202:97",
                                                   "name" : "{http://hl7.org/fhir}Age",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          } ]
                                       }, {
                                          "localId" : "511",
                                          "locator" : "202:102-202:107",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              }
                           },
                           "lowClosedExpression" : {
                              "path" : "lowClosed",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "513",
                                 "locator" : "201:3-202:108",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "499",
                                    "locator" : "201:12-201:106",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "492",
                                       "locator" : "201:12-201:48",
                                       "name" : "ToDate",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "491",
                                          "locator" : "201:31-201:47",
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "490",
                                             "locator" : "201:31-201:37",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "498",
                                       "locator" : "201:52-201:106",
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "497",
                                          "locator" : "201:75-201:105",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "495",
                                             "locator" : "201:75-201:93",
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "494",
                                                "locator" : "201:75-201:83",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "496",
                                             "locator" : "201:98-201:105",
                                             "name" : "{http://hl7.org/fhir}Age",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    } ]
                                 },
                                 "high" : {
                                    "localId" : "512",
                                    "locator" : "202:4-202:107",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "510",
                                       "locator" : "202:4-202:98",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "503",
                                          "locator" : "202:4-202:40",
                                          "name" : "ToDate",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "502",
                                             "locator" : "202:23-202:39",
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "501",
                                                "locator" : "202:23-202:29",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "509",
                                          "locator" : "202:44-202:98",
                                          "name" : "ToQuantity",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "508",
                                             "locator" : "202:67-202:97",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "506",
                                                "locator" : "202:67-202:85",
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "505",
                                                   "locator" : "202:67-202:75",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "507",
                                                "locator" : "202:90-202:97",
                                                "name" : "{http://hl7.org/fhir}Age",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       } ]
                                    }, {
                                       "localId" : "511",
                                       "locator" : "202:102-202:107",
                                       "value" : 1,
                                       "unit" : "year",
                                       "type" : "Quantity"
                                    } ]
                                 }
                              }
                           },
                           "high" : {
                              "type" : "ToDateTime",
                              "operand" : {
                                 "path" : "high",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "513",
                                    "locator" : "201:3-202:108",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "499",
                                       "locator" : "201:12-201:106",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "492",
                                          "locator" : "201:12-201:48",
                                          "name" : "ToDate",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "491",
                                             "locator" : "201:31-201:47",
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "490",
                                                "locator" : "201:31-201:37",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "498",
                                          "locator" : "201:52-201:106",
                                          "name" : "ToQuantity",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "497",
                                             "locator" : "201:75-201:105",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "495",
                                                "locator" : "201:75-201:93",
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "494",
                                                   "locator" : "201:75-201:83",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "496",
                                                "locator" : "201:98-201:105",
                                                "name" : "{http://hl7.org/fhir}Age",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "512",
                                       "locator" : "202:4-202:107",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "510",
                                          "locator" : "202:4-202:98",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "503",
                                             "locator" : "202:4-202:40",
                                             "name" : "ToDate",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "502",
                                                "locator" : "202:23-202:39",
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "501",
                                                   "locator" : "202:23-202:29",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "509",
                                             "locator" : "202:44-202:98",
                                             "name" : "ToQuantity",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "508",
                                                "locator" : "202:67-202:97",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "506",
                                                   "locator" : "202:67-202:85",
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "505",
                                                      "locator" : "202:67-202:75",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "507",
                                                   "locator" : "202:90-202:97",
                                                   "name" : "{http://hl7.org/fhir}Age",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          } ]
                                       }, {
                                          "localId" : "511",
                                          "locator" : "202:102-202:107",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              }
                           },
                           "highClosedExpression" : {
                              "path" : "highClosed",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "513",
                                 "locator" : "201:3-202:108",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "499",
                                    "locator" : "201:12-201:106",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "492",
                                       "locator" : "201:12-201:48",
                                       "name" : "ToDate",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "491",
                                          "locator" : "201:31-201:47",
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "490",
                                             "locator" : "201:31-201:37",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "498",
                                       "locator" : "201:52-201:106",
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "497",
                                          "locator" : "201:75-201:105",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "495",
                                             "locator" : "201:75-201:93",
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "494",
                                                "locator" : "201:75-201:83",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "496",
                                             "locator" : "201:98-201:105",
                                             "name" : "{http://hl7.org/fhir}Age",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    } ]
                                 },
                                 "high" : {
                                    "localId" : "512",
                                    "locator" : "202:4-202:107",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "510",
                                       "locator" : "202:4-202:98",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "503",
                                          "locator" : "202:4-202:40",
                                          "name" : "ToDate",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "502",
                                             "locator" : "202:23-202:39",
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "501",
                                                "locator" : "202:23-202:29",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "509",
                                          "locator" : "202:44-202:98",
                                          "name" : "ToQuantity",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "508",
                                             "locator" : "202:67-202:97",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "506",
                                                "locator" : "202:67-202:85",
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "505",
                                                   "locator" : "202:67-202:75",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "507",
                                                "locator" : "202:90-202:97",
                                                "name" : "{http://hl7.org/fhir}Age",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       } ]
                                    }, {
                                       "localId" : "511",
                                       "locator" : "202:102-202:107",
                                       "value" : 1,
                                       "unit" : "year",
                                       "type" : "Quantity"
                                    } ]
                                 }
                              }
                           }
                        },
                        "else" : {
                           "localId" : "558",
                           "locator" : "203:7-208:10",
                           "type" : "If",
                           "condition" : {
                              "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                              "type" : "As",
                              "operand" : {
                                 "localId" : "517",
                                 "locator" : "203:10-203:42",
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "515",
                                    "locator" : "203:10-203:28",
                                    "path" : "abatement",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "514",
                                       "locator" : "203:10-203:18",
                                       "name" : "condition",
                                       "type" : "OperandRef"
                                    }
                                 },
                                 "isTypeSpecifier" : {
                                    "localId" : "516",
                                    "locator" : "203:33-203:42",
                                    "name" : "{http://hl7.org/fhir}Range",
                                    "type" : "NamedTypeSpecifier"
                                 }
                              }
                           },
                           "then" : {
                              "type" : "Interval",
                              "low" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "path" : "low",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "544",
                                       "locator" : "204:4-205:118",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "529",
                                          "locator" : "204:13-204:115",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "521",
                                             "locator" : "204:13-204:49",
                                             "name" : "ToDate",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "520",
                                                "locator" : "204:32-204:48",
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "519",
                                                   "locator" : "204:32-204:38",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "528",
                                             "locator" : "204:53-204:115",
                                             "name" : "ToQuantity",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "527",
                                                "locator" : "204:76-204:114",
                                                "path" : "low",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "526",
                                                   "locator" : "204:76-204:110",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "524",
                                                      "locator" : "204:77-204:95",
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "523",
                                                         "locator" : "204:77-204:85",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "525",
                                                      "locator" : "204:100-204:109",
                                                      "name" : "{http://hl7.org/fhir}Range",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                }
                                             } ]
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "543",
                                          "locator" : "205:5-205:117",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "541",
                                             "locator" : "205:5-205:108",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "533",
                                                "locator" : "205:5-205:41",
                                                "name" : "ToDate",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "localId" : "532",
                                                   "locator" : "205:24-205:40",
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "531",
                                                      "locator" : "205:24-205:30",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "540",
                                                "locator" : "205:45-205:108",
                                                "name" : "ToQuantity",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "localId" : "539",
                                                   "locator" : "205:68-205:107",
                                                   "path" : "high",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "538",
                                                      "locator" : "205:68-205:102",
                                                      "strict" : false,
                                                      "type" : "As",
                                                      "operand" : {
                                                         "localId" : "536",
                                                         "locator" : "205:69-205:87",
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "535",
                                                            "locator" : "205:69-205:77",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      },
                                                      "asTypeSpecifier" : {
                                                         "localId" : "537",
                                                         "locator" : "205:92-205:101",
                                                         "name" : "{http://hl7.org/fhir}Range",
                                                         "type" : "NamedTypeSpecifier"
                                                      }
                                                   }
                                                } ]
                                             } ]
                                          }, {
                                             "localId" : "542",
                                             "locator" : "205:112-205:117",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 }
                              },
                              "lowClosedExpression" : {
                                 "path" : "lowClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "544",
                                    "locator" : "204:4-205:118",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "529",
                                       "locator" : "204:13-204:115",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "521",
                                          "locator" : "204:13-204:49",
                                          "name" : "ToDate",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "520",
                                             "locator" : "204:32-204:48",
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "519",
                                                "locator" : "204:32-204:38",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "528",
                                          "locator" : "204:53-204:115",
                                          "name" : "ToQuantity",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "527",
                                             "locator" : "204:76-204:114",
                                             "path" : "low",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "526",
                                                "locator" : "204:76-204:110",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "524",
                                                   "locator" : "204:77-204:95",
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "523",
                                                      "locator" : "204:77-204:85",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "525",
                                                   "locator" : "204:100-204:109",
                                                   "name" : "{http://hl7.org/fhir}Range",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          } ]
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "543",
                                       "locator" : "205:5-205:117",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "541",
                                          "locator" : "205:5-205:108",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "533",
                                             "locator" : "205:5-205:41",
                                             "name" : "ToDate",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "532",
                                                "locator" : "205:24-205:40",
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "531",
                                                   "locator" : "205:24-205:30",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "540",
                                             "locator" : "205:45-205:108",
                                             "name" : "ToQuantity",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "539",
                                                "locator" : "205:68-205:107",
                                                "path" : "high",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "538",
                                                   "locator" : "205:68-205:102",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "536",
                                                      "locator" : "205:69-205:87",
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "535",
                                                         "locator" : "205:69-205:77",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "537",
                                                      "locator" : "205:92-205:101",
                                                      "name" : "{http://hl7.org/fhir}Range",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                }
                                             } ]
                                          } ]
                                       }, {
                                          "localId" : "542",
                                          "locator" : "205:112-205:117",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              },
                              "high" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "path" : "high",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "544",
                                       "locator" : "204:4-205:118",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "529",
                                          "locator" : "204:13-204:115",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "521",
                                             "locator" : "204:13-204:49",
                                             "name" : "ToDate",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "520",
                                                "locator" : "204:32-204:48",
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "519",
                                                   "locator" : "204:32-204:38",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "528",
                                             "locator" : "204:53-204:115",
                                             "name" : "ToQuantity",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "527",
                                                "locator" : "204:76-204:114",
                                                "path" : "low",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "526",
                                                   "locator" : "204:76-204:110",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "524",
                                                      "locator" : "204:77-204:95",
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "523",
                                                         "locator" : "204:77-204:85",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "525",
                                                      "locator" : "204:100-204:109",
                                                      "name" : "{http://hl7.org/fhir}Range",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                }
                                             } ]
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "543",
                                          "locator" : "205:5-205:117",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "541",
                                             "locator" : "205:5-205:108",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "533",
                                                "locator" : "205:5-205:41",
                                                "name" : "ToDate",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "localId" : "532",
                                                   "locator" : "205:24-205:40",
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "531",
                                                      "locator" : "205:24-205:30",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "540",
                                                "locator" : "205:45-205:108",
                                                "name" : "ToQuantity",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "localId" : "539",
                                                   "locator" : "205:68-205:107",
                                                   "path" : "high",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "538",
                                                      "locator" : "205:68-205:102",
                                                      "strict" : false,
                                                      "type" : "As",
                                                      "operand" : {
                                                         "localId" : "536",
                                                         "locator" : "205:69-205:87",
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "535",
                                                            "locator" : "205:69-205:77",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      },
                                                      "asTypeSpecifier" : {
                                                         "localId" : "537",
                                                         "locator" : "205:92-205:101",
                                                         "name" : "{http://hl7.org/fhir}Range",
                                                         "type" : "NamedTypeSpecifier"
                                                      }
                                                   }
                                                } ]
                                             } ]
                                          }, {
                                             "localId" : "542",
                                             "locator" : "205:112-205:117",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 }
                              },
                              "highClosedExpression" : {
                                 "path" : "highClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "544",
                                    "locator" : "204:4-205:118",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "529",
                                       "locator" : "204:13-204:115",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "521",
                                          "locator" : "204:13-204:49",
                                          "name" : "ToDate",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "520",
                                             "locator" : "204:32-204:48",
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "519",
                                                "locator" : "204:32-204:38",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "528",
                                          "locator" : "204:53-204:115",
                                          "name" : "ToQuantity",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "527",
                                             "locator" : "204:76-204:114",
                                             "path" : "low",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "526",
                                                "locator" : "204:76-204:110",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "524",
                                                   "locator" : "204:77-204:95",
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "523",
                                                      "locator" : "204:77-204:85",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "525",
                                                   "locator" : "204:100-204:109",
                                                   "name" : "{http://hl7.org/fhir}Range",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          } ]
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "543",
                                       "locator" : "205:5-205:117",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "541",
                                          "locator" : "205:5-205:108",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "533",
                                             "locator" : "205:5-205:41",
                                             "name" : "ToDate",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "532",
                                                "locator" : "205:24-205:40",
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "531",
                                                   "locator" : "205:24-205:30",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "540",
                                             "locator" : "205:45-205:108",
                                             "name" : "ToQuantity",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "539",
                                                "locator" : "205:68-205:107",
                                                "path" : "high",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "538",
                                                   "locator" : "205:68-205:102",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "536",
                                                      "locator" : "205:69-205:87",
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "535",
                                                         "locator" : "205:69-205:77",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "537",
                                                      "locator" : "205:92-205:101",
                                                      "name" : "{http://hl7.org/fhir}Range",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                }
                                             } ]
                                          } ]
                                       }, {
                                          "localId" : "542",
                                          "locator" : "205:112-205:117",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              }
                           },
                           "else" : {
                              "localId" : "557",
                              "locator" : "206:7-208:10",
                              "type" : "If",
                              "condition" : {
                                 "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                                 "type" : "As",
                                 "operand" : {
                                    "localId" : "548",
                                    "locator" : "206:10-206:44",
                                    "type" : "Is",
                                    "operand" : {
                                       "localId" : "546",
                                       "locator" : "206:10-206:28",
                                       "path" : "abatement",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "545",
                                          "locator" : "206:10-206:18",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    },
                                    "isTypeSpecifier" : {
                                       "localId" : "547",
                                       "locator" : "206:33-206:44",
                                       "name" : "{http://hl7.org/fhir}boolean",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "localId" : "555",
                                 "locator" : "207:4-207:81",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "552",
                                    "locator" : "207:13-207:56",
                                    "type" : "End",
                                    "operand" : {
                                       "localId" : "551",
                                       "locator" : "207:20-207:56",
                                       "name" : "Normalize Interval",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "550",
                                          "locator" : "207:41-207:55",
                                          "path" : "onset",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "549",
                                             "locator" : "207:41-207:49",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    }
                                 },
                                 "high" : {
                                    "name" : "ToDateTime",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "554",
                                       "locator" : "207:59-207:80",
                                       "path" : "recordedDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "553",
                                          "locator" : "207:59-207:67",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 }
                              },
                              "else" : {
                                 "type" : "As",
                                 "operand" : {
                                    "localId" : "556",
                                    "locator" : "208:7-208:10",
                                    "type" : "Null"
                                 },
                                 "asTypeSpecifier" : {
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "444",
                  "locator" : "193:49-193:57",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "573",
            "locator" : "210:1-211:99",
            "name" : "Prevalence Period",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "573",
                  "s" : [ {
                     "value" : [ "define function ","\"Prevalence Period\"","(","condition"," " ]
                  }, {
                     "r" : "564",
                     "s" : [ {
                        "value" : [ "Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "572",
                     "s" : [ {
                        "r" : "572",
                        "s" : [ {
                           "value" : [ "Interval[" ]
                        }, {
                           "r" : "568",
                           "s" : [ {
                              "value" : [ "start of " ]
                           }, {
                              "r" : "567",
                              "s" : [ {
                                 "value" : [ "\"Normalize Interval\"","(" ]
                              }, {
                                 "r" : "566",
                                 "s" : [ {
                                    "r" : "565",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "566",
                                    "s" : [ {
                                       "value" : [ "onset" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ", " ]
                        }, {
                           "r" : "571",
                           "s" : [ {
                              "value" : [ "end of " ]
                           }, {
                              "r" : "570",
                              "s" : [ {
                                 "value" : [ "\"Normalize Abatement\"","(" ]
                              }, {
                                 "r" : "569",
                                 "s" : [ {
                                    "value" : [ "condition" ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "572",
               "locator" : "211:3-211:99",
               "lowClosed" : true,
               "highClosed" : false,
               "type" : "Interval",
               "low" : {
                  "localId" : "568",
                  "locator" : "211:12-211:57",
                  "type" : "Start",
                  "operand" : {
                     "localId" : "567",
                     "locator" : "211:21-211:57",
                     "name" : "Normalize Interval",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "566",
                        "locator" : "211:42-211:56",
                        "path" : "onset",
                        "type" : "Property",
                        "source" : {
                           "localId" : "565",
                           "locator" : "211:42-211:50",
                           "name" : "condition",
                           "type" : "OperandRef"
                        }
                     } ]
                  }
               },
               "high" : {
                  "localId" : "571",
                  "locator" : "211:60-211:98",
                  "type" : "End",
                  "operand" : {
                     "localId" : "570",
                     "locator" : "211:67-211:98",
                     "name" : "Normalize Abatement",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "569",
                        "locator" : "211:89-211:97",
                        "name" : "condition",
                        "type" : "OperandRef"
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "564",
                  "locator" : "210:47-210:55",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "579",
            "locator" : "213:1-214:22",
            "name" : "GetId",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "579",
                  "s" : [ {
                     "value" : [ "define function ","\"GetId\"","(","uri"," " ]
                  }, {
                     "r" : "574",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "578",
                     "s" : [ {
                        "r" : "578",
                        "s" : [ {
                           "value" : [ "Last","(" ]
                        }, {
                           "r" : "577",
                           "s" : [ {
                              "value" : [ "Split","(" ]
                           }, {
                              "r" : "575",
                              "s" : [ {
                                 "value" : [ "uri" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "576",
                              "s" : [ {
                                 "value" : [ "'/'" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "578",
               "locator" : "214:2-214:22",
               "type" : "Last",
               "source" : {
                  "localId" : "577",
                  "locator" : "214:7-214:21",
                  "type" : "Split",
                  "stringToSplit" : {
                     "localId" : "575",
                     "locator" : "214:13-214:15",
                     "name" : "uri",
                     "type" : "OperandRef"
                  },
                  "separator" : {
                     "localId" : "576",
                     "locator" : "214:18-214:20",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "/",
                     "type" : "Literal"
                  }
               }
            },
            "operand" : [ {
               "name" : "uri",
               "operandTypeSpecifier" : {
                  "localId" : "574",
                  "locator" : "213:29-213:34",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "596",
            "locator" : "217:1-219:85",
            "name" : "EncounterDiagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "596",
                  "s" : [ {
                     "value" : [ "define function ","\"EncounterDiagnosis\"","(","Encounter"," " ]
                  }, {
                     "r" : "580",
                     "s" : [ {
                        "value" : [ "Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "595",
                     "s" : [ {
                        "r" : "595",
                        "s" : [ {
                           "s" : [ {
                              "r" : "582",
                              "s" : [ {
                                 "r" : "581",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "Encounter",".","diagnosis" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","D" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n    " ]
                        }, {
                           "r" : "594",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "593",
                              "s" : [ {
                                 "value" : [ "singleton from " ]
                              }, {
                                 "r" : "592",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "592",
                                    "s" : [ {
                                       "s" : [ {
                                          "r" : "584",
                                          "s" : [ {
                                             "r" : "583",
                                             "s" : [ {
                                                "r" : "583",
                                                "s" : [ {
                                                   "value" : [ "[","Condition","]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","C" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " " ]
                                    }, {
                                       "r" : "591",
                                       "s" : [ {
                                          "value" : [ "where " ]
                                       }, {
                                          "r" : "591",
                                          "s" : [ {
                                             "r" : "586",
                                             "s" : [ {
                                                "r" : "585",
                                                "s" : [ {
                                                   "value" : [ "C" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "586",
                                                "s" : [ {
                                                   "value" : [ "id" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","="," " ]
                                          }, {
                                             "r" : "590",
                                             "s" : [ {
                                                "value" : [ "\"GetId\"","(" ]
                                             }, {
                                                "r" : "589",
                                                "s" : [ {
                                                   "r" : "588",
                                                   "s" : [ {
                                                      "r" : "587",
                                                      "s" : [ {
                                                         "value" : [ "D" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "588",
                                                      "s" : [ {
                                                         "value" : [ "condition" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "589",
                                                   "s" : [ {
                                                      "value" : [ "reference" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ ")" ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "595",
               "locator" : "218:3-219:85",
               "type" : "Query",
               "source" : [ {
                  "localId" : "582",
                  "locator" : "218:3-218:23",
                  "alias" : "D",
                  "expression" : {
                     "localId" : "581",
                     "locator" : "218:3-218:21",
                     "path" : "diagnosis",
                     "type" : "Property",
                     "source" : {
                        "name" : "Encounter",
                        "type" : "OperandRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "594",
                  "locator" : "219:5-219:85",
                  "expression" : {
                     "localId" : "593",
                     "locator" : "219:12-219:85",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "592",
                        "locator" : "219:27-219:85",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "584",
                           "locator" : "219:28-219:40",
                           "alias" : "C",
                           "expression" : {
                              "localId" : "583",
                              "locator" : "219:28-219:38",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Condition",
                              "type" : "Retrieve"
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "591",
                           "locator" : "219:42-219:84",
                           "type" : "Equal",
                           "operand" : [ {
                              "name" : "ToString",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "586",
                                 "locator" : "219:48-219:51",
                                 "path" : "id",
                                 "scope" : "C",
                                 "type" : "Property"
                              } ]
                           }, {
                              "localId" : "590",
                              "locator" : "219:55-219:84",
                              "name" : "GetId",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "ToString",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "589",
                                    "locator" : "219:63-219:83",
                                    "path" : "reference",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "588",
                                       "locator" : "219:63-219:73",
                                       "path" : "condition",
                                       "scope" : "D",
                                       "type" : "Property"
                                    }
                                 } ]
                              } ]
                           } ]
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "Encounter",
               "operandTypeSpecifier" : {
                  "localId" : "580",
                  "locator" : "217:48-217:56",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "622",
            "locator" : "223:1-225:84",
            "name" : "PrincipalDiagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "622",
                  "s" : [ {
                     "value" : [ "define function ","\"PrincipalDiagnosis\"","(","Encounter"," " ]
                  }, {
                     "r" : "597",
                     "s" : [ {
                        "value" : [ "Encounter" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n\t" ]
                  }, {
                     "r" : "621",
                     "s" : [ {
                        "r" : "621",
                        "s" : [ {
                           "s" : [ {
                              "r" : "608",
                              "s" : [ {
                                 "r" : "607",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "607",
                                    "s" : [ {
                                       "value" : [ "singleton from " ]
                                    }, {
                                       "r" : "606",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "606",
                                          "s" : [ {
                                             "s" : [ {
                                                "r" : "599",
                                                "s" : [ {
                                                   "r" : "598",
                                                   "s" : [ {
                                                      "s" : [ {
                                                         "value" : [ "Encounter",".","diagnosis" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ " ","D" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " " ]
                                          }, {
                                             "r" : "605",
                                             "s" : [ {
                                                "value" : [ "where " ]
                                             }, {
                                                "r" : "605",
                                                "s" : [ {
                                                   "r" : "603",
                                                   "s" : [ {
                                                      "r" : "600",
                                                      "s" : [ {
                                                         "value" : [ "FHIRHelpers" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "603",
                                                      "s" : [ {
                                                         "value" : [ "ToInteger","(" ]
                                                      }, {
                                                         "r" : "602",
                                                         "s" : [ {
                                                            "r" : "601",
                                                            "s" : [ {
                                                               "value" : [ "D" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ "." ]
                                                         }, {
                                                            "r" : "602",
                                                            "s" : [ {
                                                               "value" : [ "rank" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ ")" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "r" : "604",
                                                   "value" : [ " ","="," ","1" ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ " ","PD" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "620",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "619",
                              "s" : [ {
                                 "value" : [ "singleton from " ]
                              }, {
                                 "r" : "618",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "618",
                                    "s" : [ {
                                       "s" : [ {
                                          "r" : "610",
                                          "s" : [ {
                                             "r" : "609",
                                             "s" : [ {
                                                "r" : "609",
                                                "s" : [ {
                                                   "value" : [ "[","Condition","]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","C" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " " ]
                                    }, {
                                       "r" : "617",
                                       "s" : [ {
                                          "value" : [ "where " ]
                                       }, {
                                          "r" : "617",
                                          "s" : [ {
                                             "r" : "612",
                                             "s" : [ {
                                                "r" : "611",
                                                "s" : [ {
                                                   "value" : [ "C" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "612",
                                                "s" : [ {
                                                   "value" : [ "id" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","="," " ]
                                          }, {
                                             "r" : "616",
                                             "s" : [ {
                                                "value" : [ "\"GetId\"","(" ]
                                             }, {
                                                "r" : "615",
                                                "s" : [ {
                                                   "r" : "614",
                                                   "s" : [ {
                                                      "r" : "613",
                                                      "s" : [ {
                                                         "value" : [ "PD" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "614",
                                                      "s" : [ {
                                                         "value" : [ "condition" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "615",
                                                   "s" : [ {
                                                      "value" : [ "reference" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ ")" ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "621",
               "locator" : "224:2-225:84",
               "type" : "Query",
               "source" : [ {
                  "localId" : "608",
                  "locator" : "224:2-224:84",
                  "alias" : "PD",
                  "expression" : {
                     "localId" : "607",
                     "locator" : "224:2-224:81",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "606",
                        "locator" : "224:18-224:80",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "599",
                           "locator" : "224:19-224:39",
                           "alias" : "D",
                           "expression" : {
                              "localId" : "598",
                              "locator" : "224:19-224:37",
                              "path" : "diagnosis",
                              "type" : "Property",
                              "source" : {
                                 "name" : "Encounter",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "605",
                           "locator" : "224:41-224:79",
                           "type" : "Equal",
                           "operand" : [ {
                              "localId" : "603",
                              "locator" : "224:47-224:75",
                              "name" : "ToInteger",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "602",
                                 "locator" : "224:69-224:74",
                                 "path" : "rank",
                                 "scope" : "D",
                                 "type" : "Property"
                              } ]
                           }, {
                              "localId" : "604",
                              "locator" : "224:79",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "1",
                              "type" : "Literal"
                           } ]
                        }
                     }
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "620",
                  "locator" : "225:3-225:84",
                  "expression" : {
                     "localId" : "619",
                     "locator" : "225:10-225:84",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "618",
                        "locator" : "225:25-225:84",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "610",
                           "locator" : "225:26-225:38",
                           "alias" : "C",
                           "expression" : {
                              "localId" : "609",
                              "locator" : "225:26-225:36",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Condition",
                              "type" : "Retrieve"
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "617",
                           "locator" : "225:40-225:83",
                           "type" : "Equal",
                           "operand" : [ {
                              "name" : "ToString",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "612",
                                 "locator" : "225:46-225:49",
                                 "path" : "id",
                                 "scope" : "C",
                                 "type" : "Property"
                              } ]
                           }, {
                              "localId" : "616",
                              "locator" : "225:53-225:83",
                              "name" : "GetId",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "ToString",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "615",
                                    "locator" : "225:61-225:82",
                                    "path" : "reference",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "614",
                                       "locator" : "225:61-225:72",
                                       "path" : "condition",
                                       "scope" : "PD",
                                       "type" : "Property"
                                    }
                                 } ]
                              } ]
                           } ]
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "Encounter",
               "operandTypeSpecifier" : {
                  "localId" : "597",
                  "locator" : "223:48-223:56",
                  "name" : "{http://hl7.org/fhir}Encounter",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "634",
            "locator" : "228:1-231:3",
            "name" : "GetLocation",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "634",
                  "s" : [ {
                     "value" : [ "define function ","GetLocation","(","reference"," " ]
                  }, {
                     "r" : "623",
                     "s" : [ {
                        "value" : [ "Reference" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "633",
                     "s" : [ {
                        "r" : "633",
                        "s" : [ {
                           "value" : [ "singleton from " ]
                        }, {
                           "r" : "632",
                           "s" : [ {
                              "value" : [ "(\r\n    " ]
                           }, {
                              "r" : "632",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "625",
                                    "s" : [ {
                                       "r" : "624",
                                       "s" : [ {
                                          "r" : "624",
                                          "s" : [ {
                                             "value" : [ "[","Location","]" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","L" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "631",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "631",
                                    "s" : [ {
                                       "r" : "627",
                                       "s" : [ {
                                          "r" : "626",
                                          "s" : [ {
                                             "value" : [ "L" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "627",
                                          "s" : [ {
                                             "value" : [ "id" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","="," " ]
                                    }, {
                                       "r" : "630",
                                       "s" : [ {
                                          "value" : [ "GetId","(" ]
                                       }, {
                                          "r" : "629",
                                          "s" : [ {
                                             "r" : "628",
                                             "s" : [ {
                                                "value" : [ "reference" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "629",
                                             "s" : [ {
                                                "value" : [ "reference" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "633",
               "locator" : "229:3-231:3",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "632",
                  "locator" : "229:18-231:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "625",
                     "locator" : "230:5-230:16",
                     "alias" : "L",
                     "expression" : {
                        "localId" : "624",
                        "locator" : "230:5-230:14",
                        "dataType" : "{http://hl7.org/fhir}Location",
                        "templateId" : "http://hl7.org/fhir/StructureDefinition/Location",
                        "type" : "Retrieve"
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "631",
                     "locator" : "230:18-230:56",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "627",
                           "locator" : "230:24-230:27",
                           "path" : "id",
                           "scope" : "L",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "630",
                        "locator" : "230:31-230:56",
                        "name" : "GetId",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "name" : "ToString",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "629",
                              "locator" : "230:37-230:55",
                              "path" : "reference",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "628",
                                 "locator" : "230:37-230:45",
                                 "name" : "reference",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "reference",
               "operandTypeSpecifier" : {
                  "localId" : "623",
                  "locator" : "228:39-228:47",
                  "name" : "{http://hl7.org/fhir}Reference",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "648",
            "locator" : "238:1-241:10",
            "name" : "GetExtensions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "648",
                  "s" : [ {
                     "value" : [ "define function ","\"GetExtensions\"","(","domainResource"," " ]
                  }, {
                     "r" : "635",
                     "s" : [ {
                        "value" : [ "DomainResource" ]
                     } ]
                  }, {
                     "value" : [ ", ","url"," " ]
                  }, {
                     "r" : "636",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "647",
                     "s" : [ {
                        "r" : "647",
                        "s" : [ {
                           "s" : [ {
                              "r" : "638",
                              "s" : [ {
                                 "r" : "637",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "domainResource",".","extension" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","E" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t  " ]
                        }, {
                           "r" : "644",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "644",
                              "s" : [ {
                                 "r" : "640",
                                 "s" : [ {
                                    "r" : "639",
                                    "s" : [ {
                                       "value" : [ "E" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "640",
                                    "s" : [ {
                                       "value" : [ "url" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "643",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "643",
                                    "s" : [ {
                                       "r" : "641",
                                       "s" : [ {
                                          "value" : [ "'http://hl7.org/fhir/us/qicore/StructureDefinition/'" ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "642",
                                       "s" : [ {
                                          "value" : [ "url" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "646",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "645",
                              "s" : [ {
                                 "value" : [ "E" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "647",
               "locator" : "239:3-241:10",
               "type" : "Query",
               "source" : [ {
                  "localId" : "638",
                  "locator" : "239:3-239:28",
                  "alias" : "E",
                  "expression" : {
                     "localId" : "637",
                     "locator" : "239:3-239:26",
                     "path" : "extension",
                     "type" : "Property",
                     "source" : {
                        "name" : "domainResource",
                        "type" : "OperandRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "644",
                  "locator" : "240:4-240:77",
                  "type" : "Equal",
                  "operand" : [ {
                     "name" : "ToString",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "640",
                        "locator" : "240:10-240:14",
                        "path" : "url",
                        "scope" : "E",
                        "type" : "Property"
                     } ]
                  }, {
                     "localId" : "643",
                     "locator" : "240:18-240:77",
                     "type" : "Concatenate",
                     "operand" : [ {
                        "localId" : "641",
                        "locator" : "240:19-240:70",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "http://hl7.org/fhir/us/qicore/StructureDefinition/",
                        "type" : "Literal"
                     }, {
                        "localId" : "642",
                        "locator" : "240:74-240:76",
                        "name" : "url",
                        "type" : "OperandRef"
                     } ]
                  } ]
               },
               "return" : {
                  "localId" : "646",
                  "locator" : "241:3-241:10",
                  "expression" : {
                     "localId" : "645",
                     "locator" : "241:10",
                     "name" : "E",
                     "type" : "AliasRef"
                  }
               }
            },
            "operand" : [ {
               "name" : "domainResource",
               "operandTypeSpecifier" : {
                  "localId" : "635",
                  "locator" : "238:48-238:61",
                  "name" : "{http://hl7.org/fhir}DomainResource",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "url",
               "operandTypeSpecifier" : {
                  "localId" : "636",
                  "locator" : "238:68-238:73",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "655",
            "locator" : "243:1-244:53",
            "name" : "GetExtension",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "655",
                  "s" : [ {
                     "value" : [ "define function ","\"GetExtension\"","(","domainResource"," " ]
                  }, {
                     "r" : "649",
                     "s" : [ {
                        "value" : [ "DomainResource" ]
                     } ]
                  }, {
                     "value" : [ ", ","url"," " ]
                  }, {
                     "r" : "650",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "654",
                     "s" : [ {
                        "r" : "654",
                        "s" : [ {
                           "value" : [ "singleton from " ]
                        }, {
                           "r" : "653",
                           "s" : [ {
                              "value" : [ "\"GetExtensions\"","(" ]
                           }, {
                              "r" : "651",
                              "s" : [ {
                                 "value" : [ "domainResource" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "652",
                              "s" : [ {
                                 "value" : [ "url" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "654",
               "locator" : "244:3-244:53",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "653",
                  "locator" : "244:18-244:53",
                  "name" : "GetExtensions",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "651",
                     "locator" : "244:34-244:47",
                     "name" : "domainResource",
                     "type" : "OperandRef"
                  }, {
                     "localId" : "652",
                     "locator" : "244:50-244:52",
                     "name" : "url",
                     "type" : "OperandRef"
                  } ]
               }
            },
            "operand" : [ {
               "name" : "domainResource",
               "operandTypeSpecifier" : {
                  "localId" : "649",
                  "locator" : "243:47-243:60",
                  "name" : "{http://hl7.org/fhir}DomainResource",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "url",
               "operandTypeSpecifier" : {
                  "localId" : "650",
                  "locator" : "243:67-243:72",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "667",
            "locator" : "251:1-254:10",
            "name" : "GetExtensions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "667",
                  "s" : [ {
                     "value" : [ "define function ","\"GetExtensions\"","(","element"," " ]
                  }, {
                     "r" : "656",
                     "s" : [ {
                        "value" : [ "Element" ]
                     } ]
                  }, {
                     "value" : [ ", ","url"," " ]
                  }, {
                     "r" : "657",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "666",
                     "s" : [ {
                        "r" : "666",
                        "s" : [ {
                           "s" : [ {
                              "r" : "659",
                              "s" : [ {
                                 "r" : "658",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "element",".","extension" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","E" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t  " ]
                        }, {
                           "r" : "663",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "663",
                              "s" : [ {
                                 "r" : "661",
                                 "s" : [ {
                                    "r" : "660",
                                    "s" : [ {
                                       "value" : [ "E" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "661",
                                    "s" : [ {
                                       "value" : [ "url" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "662",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "662",
                                    "s" : [ {
                                       "value" : [ "url" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "665",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "664",
                              "s" : [ {
                                 "value" : [ "E" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "666",
               "locator" : "252:3-254:10",
               "type" : "Query",
               "source" : [ {
                  "localId" : "659",
                  "locator" : "252:3-252:21",
                  "alias" : "E",
                  "expression" : {
                     "localId" : "658",
                     "locator" : "252:3-252:19",
                     "path" : "extension",
                     "type" : "Property",
                     "source" : {
                        "name" : "element",
                        "type" : "OperandRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "663",
                  "locator" : "253:4-253:22",
                  "type" : "Equal",
                  "operand" : [ {
                     "name" : "ToString",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "661",
                        "locator" : "253:10-253:14",
                        "path" : "url",
                        "scope" : "E",
                        "type" : "Property"
                     } ]
                  }, {
                     "localId" : "662",
                     "locator" : "253:18-253:22",
                     "name" : "url",
                     "type" : "OperandRef"
                  } ]
               },
               "return" : {
                  "localId" : "665",
                  "locator" : "254:3-254:10",
                  "expression" : {
                     "localId" : "664",
                     "locator" : "254:10",
                     "name" : "E",
                     "type" : "AliasRef"
                  }
               }
            },
            "operand" : [ {
               "name" : "element",
               "operandTypeSpecifier" : {
                  "localId" : "656",
                  "locator" : "251:41-251:47",
                  "name" : "{http://hl7.org/fhir}Element",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "url",
               "operandTypeSpecifier" : {
                  "localId" : "657",
                  "locator" : "251:54-251:59",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "674",
            "locator" : "256:1-257:46",
            "name" : "GetExtension",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "674",
                  "s" : [ {
                     "value" : [ "define function ","\"GetExtension\"","(","element"," " ]
                  }, {
                     "r" : "668",
                     "s" : [ {
                        "value" : [ "Element" ]
                     } ]
                  }, {
                     "value" : [ ", ","url"," " ]
                  }, {
                     "r" : "669",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "673",
                     "s" : [ {
                        "r" : "673",
                        "s" : [ {
                           "value" : [ "singleton from " ]
                        }, {
                           "r" : "672",
                           "s" : [ {
                              "value" : [ "\"GetExtensions\"","(" ]
                           }, {
                              "r" : "670",
                              "s" : [ {
                                 "value" : [ "element" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "671",
                              "s" : [ {
                                 "value" : [ "url" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "673",
               "locator" : "257:3-257:46",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "672",
                  "locator" : "257:18-257:46",
                  "name" : "GetExtensions",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "670",
                     "locator" : "257:34-257:40",
                     "name" : "element",
                     "type" : "OperandRef"
                  }, {
                     "localId" : "671",
                     "locator" : "257:43-257:45",
                     "name" : "url",
                     "type" : "OperandRef"
                  } ]
               }
            },
            "operand" : [ {
               "name" : "element",
               "operandTypeSpecifier" : {
                  "localId" : "668",
                  "locator" : "256:40-256:46",
                  "name" : "{http://hl7.org/fhir}Element",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "url",
               "operandTypeSpecifier" : {
                  "localId" : "669",
                  "locator" : "256:53-256:58",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "688",
            "locator" : "264:1-267:10",
            "name" : "GetBaseExtensions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "688",
                  "s" : [ {
                     "value" : [ "define function ","\"GetBaseExtensions\"","(","domainResource"," " ]
                  }, {
                     "r" : "675",
                     "s" : [ {
                        "value" : [ "DomainResource" ]
                     } ]
                  }, {
                     "value" : [ ", ","url"," " ]
                  }, {
                     "r" : "676",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "687",
                     "s" : [ {
                        "r" : "687",
                        "s" : [ {
                           "s" : [ {
                              "r" : "678",
                              "s" : [ {
                                 "r" : "677",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "domainResource",".","extension" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","E" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t  " ]
                        }, {
                           "r" : "684",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "684",
                              "s" : [ {
                                 "r" : "680",
                                 "s" : [ {
                                    "r" : "679",
                                    "s" : [ {
                                       "value" : [ "E" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "680",
                                    "s" : [ {
                                       "value" : [ "url" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "683",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "683",
                                    "s" : [ {
                                       "r" : "681",
                                       "s" : [ {
                                          "value" : [ "'http://hl7.org/fhir/StructureDefinition/'" ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "682",
                                       "s" : [ {
                                          "value" : [ "url" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\t\t" ]
                        }, {
                           "r" : "686",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "685",
                              "s" : [ {
                                 "value" : [ "E" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "687",
               "locator" : "265:3-267:10",
               "type" : "Query",
               "source" : [ {
                  "localId" : "678",
                  "locator" : "265:3-265:28",
                  "alias" : "E",
                  "expression" : {
                     "localId" : "677",
                     "locator" : "265:3-265:26",
                     "path" : "extension",
                     "type" : "Property",
                     "source" : {
                        "name" : "domainResource",
                        "type" : "OperandRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "684",
                  "locator" : "266:4-266:67",
                  "type" : "Equal",
                  "operand" : [ {
                     "name" : "ToString",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "680",
                        "locator" : "266:10-266:14",
                        "path" : "url",
                        "scope" : "E",
                        "type" : "Property"
                     } ]
                  }, {
                     "localId" : "683",
                     "locator" : "266:18-266:67",
                     "type" : "Concatenate",
                     "operand" : [ {
                        "localId" : "681",
                        "locator" : "266:19-266:60",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "http://hl7.org/fhir/StructureDefinition/",
                        "type" : "Literal"
                     }, {
                        "localId" : "682",
                        "locator" : "266:64-266:66",
                        "name" : "url",
                        "type" : "OperandRef"
                     } ]
                  } ]
               },
               "return" : {
                  "localId" : "686",
                  "locator" : "267:3-267:10",
                  "expression" : {
                     "localId" : "685",
                     "locator" : "267:10",
                     "name" : "E",
                     "type" : "AliasRef"
                  }
               }
            },
            "operand" : [ {
               "name" : "domainResource",
               "operandTypeSpecifier" : {
                  "localId" : "675",
                  "locator" : "264:52-264:65",
                  "name" : "{http://hl7.org/fhir}DomainResource",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "url",
               "operandTypeSpecifier" : {
                  "localId" : "676",
                  "locator" : "264:72-264:77",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "695",
            "locator" : "269:1-270:57",
            "name" : "GetBaseExtension",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "695",
                  "s" : [ {
                     "value" : [ "define function ","\"GetBaseExtension\"","(","domainResource"," " ]
                  }, {
                     "r" : "689",
                     "s" : [ {
                        "value" : [ "DomainResource" ]
                     } ]
                  }, {
                     "value" : [ ", ","url"," " ]
                  }, {
                     "r" : "690",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "694",
                     "s" : [ {
                        "r" : "694",
                        "s" : [ {
                           "value" : [ "singleton from " ]
                        }, {
                           "r" : "693",
                           "s" : [ {
                              "value" : [ "\"GetBaseExtensions\"","(" ]
                           }, {
                              "r" : "691",
                              "s" : [ {
                                 "value" : [ "domainResource" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "692",
                              "s" : [ {
                                 "value" : [ "url" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "694",
               "locator" : "270:3-270:57",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "693",
                  "locator" : "270:18-270:57",
                  "name" : "GetBaseExtensions",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "691",
                     "locator" : "270:38-270:51",
                     "name" : "domainResource",
                     "type" : "OperandRef"
                  }, {
                     "localId" : "692",
                     "locator" : "270:54-270:56",
                     "name" : "url",
                     "type" : "OperandRef"
                  } ]
               }
            },
            "operand" : [ {
               "name" : "domainResource",
               "operandTypeSpecifier" : {
                  "localId" : "689",
                  "locator" : "269:51-269:64",
                  "name" : "{http://hl7.org/fhir}DomainResource",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "url",
               "operandTypeSpecifier" : {
                  "localId" : "690",
                  "locator" : "269:71-269:76",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "699",
            "locator" : "276:1-277:54",
            "name" : "GetProvenance",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "699",
                  "s" : [ {
                     "value" : [ "define function ","\"GetProvenance\"","(","resource"," " ]
                  }, {
                     "r" : "696",
                     "s" : [ {
                        "value" : [ "Resource" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "698",
                     "s" : [ {
                        "r" : "698",
                        "s" : [ {
                           "value" : [ "singleton from " ]
                        }, {
                           "r" : "697",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "697",
                              "s" : [ {
                                 "value" : [ "[","Provenance",": " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "target" ]
                                 } ]
                              }, {
                                 "value" : [ " in " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "resource",".","id" ]
                                 } ]
                              }, {
                                 "value" : [ "]" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "698",
               "locator" : "277:3-277:54",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "697",
                  "locator" : "277:18-277:54",
                  "dataType" : "{http://hl7.org/fhir}Provenance",
                  "templateId" : "http://hl7.org/fhir/StructureDefinition/Provenance",
                  "codeProperty" : "target",
                  "type" : "Retrieve",
                  "codes" : {
                     "type" : "ToList",
                     "operand" : {
                        "locator" : "277:42-277:52",
                        "path" : "id",
                        "type" : "Property",
                        "source" : {
                           "name" : "resource",
                           "type" : "OperandRef"
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "resource",
               "operandTypeSpecifier" : {
                  "localId" : "696",
                  "locator" : "276:42-276:49",
                  "name" : "{http://hl7.org/fhir}Resource",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "724",
            "locator" : "279:1-283:105",
            "name" : "GetMedicationCode",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "724",
                  "s" : [ {
                     "value" : [ "define function ","\"GetMedicationCode\"","(","request"," " ]
                  }, {
                     "r" : "700",
                     "s" : [ {
                        "value" : [ "MedicationRequest" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n  " ]
                  }, {
                     "r" : "723",
                     "s" : [ {
                        "r" : "723",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "704",
                           "s" : [ {
                              "r" : "702",
                              "s" : [ {
                                 "r" : "701",
                                 "s" : [ {
                                    "value" : [ "request" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "702",
                                 "s" : [ {
                                    "value" : [ "medication" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " is " ]
                           }, {
                              "r" : "703",
                              "s" : [ {
                                 "value" : [ "CodeableConcept" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " then\r\n\t  " ]
                        }, {
                           "r" : "708",
                           "s" : [ {
                              "r" : "706",
                              "s" : [ {
                                 "r" : "705",
                                 "s" : [ {
                                    "value" : [ "request" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "706",
                                 "s" : [ {
                                    "value" : [ "medication" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " as " ]
                           }, {
                              "r" : "707",
                              "s" : [ {
                                 "value" : [ "CodeableConcept" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\r\n\telse\r\n\t  " ]
                        }, {
                           "r" : "722",
                           "s" : [ {
                              "r" : "721",
                              "s" : [ {
                                 "value" : [ "(" ]
                              }, {
                                 "r" : "721",
                                 "s" : [ {
                                    "value" : [ "singleton from " ]
                                 }, {
                                    "r" : "720",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "720",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "710",
                                             "s" : [ {
                                                "r" : "709",
                                                "s" : [ {
                                                   "r" : "709",
                                                   "s" : [ {
                                                      "value" : [ "[","Medication","]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","M" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " " ]
                                       }, {
                                          "r" : "719",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "719",
                                             "s" : [ {
                                                "r" : "712",
                                                "s" : [ {
                                                   "r" : "711",
                                                   "s" : [ {
                                                      "value" : [ "M" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "712",
                                                   "s" : [ {
                                                      "value" : [ "id" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","="," " ]
                                             }, {
                                                "r" : "718",
                                                "s" : [ {
                                                   "value" : [ "GetId","(" ]
                                                }, {
                                                   "r" : "717",
                                                   "s" : [ {
                                                      "r" : "716",
                                                      "s" : [ {
                                                         "value" : [ "(" ]
                                                      }, {
                                                         "r" : "716",
                                                         "s" : [ {
                                                            "r" : "714",
                                                            "s" : [ {
                                                               "r" : "713",
                                                               "s" : [ {
                                                                  "value" : [ "request" ]
                                                               } ]
                                                            }, {
                                                               "value" : [ "." ]
                                                            }, {
                                                               "r" : "714",
                                                               "s" : [ {
                                                                  "value" : [ "medication" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " as " ]
                                                         }, {
                                                            "r" : "715",
                                                            "s" : [ {
                                                               "value" : [ "Reference" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ ")" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "717",
                                                      "s" : [ {
                                                         "value" : [ "reference" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "722",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "723",
               "locator" : "280:3-283:105",
               "type" : "If",
               "condition" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                  "type" : "As",
                  "operand" : {
                     "localId" : "704",
                     "locator" : "280:6-280:42",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "702",
                        "locator" : "280:6-280:23",
                        "path" : "medication",
                        "type" : "Property",
                        "source" : {
                           "localId" : "701",
                           "locator" : "280:6-280:12",
                           "name" : "request",
                           "type" : "OperandRef"
                        }
                     },
                     "isTypeSpecifier" : {
                        "localId" : "703",
                        "locator" : "280:28-280:42",
                        "name" : "{http://hl7.org/fhir}CodeableConcept",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               },
               "then" : {
                  "localId" : "708",
                  "locator" : "281:4-281:40",
                  "strict" : false,
                  "type" : "As",
                  "operand" : {
                     "localId" : "706",
                     "locator" : "281:4-281:21",
                     "path" : "medication",
                     "type" : "Property",
                     "source" : {
                        "localId" : "705",
                        "locator" : "281:4-281:10",
                        "name" : "request",
                        "type" : "OperandRef"
                     }
                  },
                  "asTypeSpecifier" : {
                     "localId" : "707",
                     "locator" : "281:26-281:40",
                     "name" : "{http://hl7.org/fhir}CodeableConcept",
                     "type" : "NamedTypeSpecifier"
                  }
               },
               "else" : {
                  "localId" : "722",
                  "locator" : "283:4-283:105",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "721",
                     "locator" : "283:4-283:100",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "720",
                        "locator" : "283:20-283:99",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "710",
                           "locator" : "283:21-283:34",
                           "alias" : "M",
                           "expression" : {
                              "localId" : "709",
                              "locator" : "283:21-283:32",
                              "dataType" : "{http://hl7.org/fhir}Medication",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Medication",
                              "type" : "Retrieve"
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "719",
                           "locator" : "283:36-283:98",
                           "type" : "Equal",
                           "operand" : [ {
                              "name" : "ToString",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "712",
                                 "locator" : "283:42-283:45",
                                 "path" : "id",
                                 "scope" : "M",
                                 "type" : "Property"
                              } ]
                           }, {
                              "localId" : "718",
                              "locator" : "283:49-283:98",
                              "name" : "GetId",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "ToString",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "717",
                                    "locator" : "283:55-283:97",
                                    "path" : "reference",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "716",
                                       "locator" : "283:55-283:87",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "714",
                                          "locator" : "283:56-283:73",
                                          "path" : "medication",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "713",
                                             "locator" : "283:56-283:62",
                                             "name" : "request",
                                             "type" : "OperandRef"
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "715",
                                          "locator" : "283:78-283:86",
                                          "name" : "{http://hl7.org/fhir}Reference",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 } ]
                              } ]
                           } ]
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "request",
               "operandTypeSpecifier" : {
                  "localId" : "700",
                  "locator" : "279:45-279:61",
                  "name" : "{http://hl7.org/fhir}MedicationRequest",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         } ]
      }
   }
}" + } ] + }, + "request": { + "method": "PUT", + "url": "Library/library-MATGlobalCommonFunctions-5.0.000" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.666.5.307", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.666.5.307" + } ], + "version": "20170504", + "name": "EncounterInpatient", + "title": "Encounter Inpatient", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://snomed.info/sct", + "version": "2018-03", + "concept": [ { + "code": "183452005", + "display": "Emergency hospital admission (procedure)" + }, { + "code": "32485007", + "display": "Hospital admission (procedure)" + }, { + "code": "8715000", + "display": "Hospital admission, elective (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.666.5.307" + } + }, { + "resource": { + "resourceType": "Library", + "id": "library-AdultOutpatientEncounters-2.0.000", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "#cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/dbcg/connectathon/Library/AdultOutpatientEncounters", + "version": "2.0.000", + "name": "AdultOutpatientEncounters", + "status": "active", + "experimental": true, + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } ] + }, + "relatedArtifact": [ { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIRHelpers|4.0.1" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + }, { + "type": "depends-on", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } ], + "parameter": [ { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Patient" + }, { + "name": "Qualifying Encounters", + "use": "out", + "min": 0, + "max": "*", + "type": "Encounter" + } ], + "dataRequirement": [ { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + } ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Encounter" ], + "codeFilter": [ { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } ] + } ], + "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 translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <identifier id="AdultOutpatientEncounters" system="http://fhir.org/guides/dbcg/connectathon" version="2.0.000"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="17:1-17:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1"/>
   </usings>
   <includes>
      <def localId="2" locator="19:1-19:54" localIdentifier="FHIRHelpers" path="http://hl7.org/fhir/FHIRHelpers" version="4.0.1"/>
   </includes>
   <parameters>
      <def localId="13" locator="27:1-28:66" name="Measurement Period" accessLevel="Public">
         <default localId="10" locator="28:11-28:66" lowClosed="true" highClosed="false" xsi:type="Interval">
            <low localId="8" locator="28:20-28:41" xsi:type="DateTime">
               <year valueType="t:Integer" value="2019" xsi:type="Literal"/>
               <month valueType="t:Integer" value="1" xsi:type="Literal"/>
               <day valueType="t:Integer" value="1" xsi:type="Literal"/>
               <hour valueType="t:Integer" value="0" xsi:type="Literal"/>
               <minute valueType="t:Integer" value="0" xsi:type="Literal"/>
               <second valueType="t:Integer" value="0" xsi:type="Literal"/>
               <millisecond valueType="t:Integer" value="0" xsi:type="Literal"/>
            </low>
            <high localId="9" locator="28:44-28:65" xsi:type="DateTime">
               <year valueType="t:Integer" value="2020" xsi:type="Literal"/>
               <month valueType="t:Integer" value="1" xsi:type="Literal"/>
               <day valueType="t:Integer" value="1" xsi:type="Literal"/>
               <hour valueType="t:Integer" value="0" xsi:type="Literal"/>
               <minute valueType="t:Integer" value="0" xsi:type="Literal"/>
               <second valueType="t:Integer" value="0" xsi:type="Literal"/>
               <millisecond valueType="t:Integer" value="0" xsi:type="Literal"/>
            </high>
         </default>
         <parameterTypeSpecifier localId="12" locator="27:32-27:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="11" locator="27:41-27:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <valueSets>
      <def localId="3" locator="21:1-21:104" name="Office Visit" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" accessLevel="Public"/>
      <def localId="4" locator="22:1-22:103" name="Annual Wellness Visit" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" accessLevel="Public"/>
      <def localId="5" locator="23:1-23:154" name="Preventive Care Services - Established Office Visit, 18 and Up" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" accessLevel="Public"/>
      <def localId="6" locator="24:1-24:148" name="Preventive Care Services-Initial Office Visit, 18 and Up" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" accessLevel="Public"/>
      <def localId="7" locator="25:1-25:116" name="Home Healthcare Services" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" accessLevel="Public"/>
   </valueSets>
   <statements>
      <def locator="30:1-30:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="30:1-30:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/StructureDefinition/Patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="34" locator="32:1-41:43" name="Qualifying Encounters" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="34">
               <a:s>define &quot;Qualifying Encounters&quot;:&#xd;
	</a:s>
               <a:s r="33">
                  <a:s>
                     <a:s r="23">
                        <a:s r="22">
                           <a:s>(&#xd;
    </a:s>
                           <a:s r="22">
                              <a:s r="20">
                                 <a:s r="18">
                                    <a:s r="16">
                                       <a:s r="14">
                                          <a:s>[Encounter: </a:s>
                                          <a:s>
                                             <a:s>&quot;Office Visit&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                       <a:s>&#xd;
  		union </a:s>
                                       <a:s r="15">
                                          <a:s>[Encounter: </a:s>
                                          <a:s>
                                             <a:s>&quot;Annual Wellness Visit&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>&#xd;
  		union </a:s>
                                    <a:s r="17">
                                       <a:s>[Encounter: </a:s>
                                       <a:s>
                                          <a:s>&quot;Preventive Care Services - Established Office Visit, 18 and Up&quot;</a:s>
                                       </a:s>
                                       <a:s>]</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>&#xd;
  		union </a:s>
                                 <a:s r="19">
                                    <a:s>[Encounter: </a:s>
                                    <a:s>
                                       <a:s>&quot;Preventive Care Services-Initial Office Visit, 18 and Up&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>&#xd;
  		union </a:s>
                              <a:s r="21">
                                 <a:s>[Encounter: </a:s>
                                 <a:s>
                                    <a:s>&quot;Home Healthcare Services&quot;</a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                           </a:s>
                           <a:s>&#xd;
  )</a:s>
                        </a:s>
                        <a:s> ValidEncounter</a:s>
                     </a:s>
                  </a:s>
                  <a:s>&#xd;
		</a:s>
                  <a:s r="32">
                     <a:s>where </a:s>
                     <a:s r="32">
                        <a:s r="27">
                           <a:s r="25">
                              <a:s r="24">
                                 <a:s>ValidEncounter</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="25">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="27"> during </a:s>
                           <a:s r="26">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
  		and </a:s>
                        <a:s r="31">
                           <a:s r="29">
                              <a:s r="28">
                                 <a:s>ValidEncounter</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="29">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s>  = </a:s>
                           <a:s r="30">
                              <a:s>'finished'</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="33" locator="33:2-41:43" xsi:type="Query">
            <source localId="23" locator="33:2-39:18" alias="ValidEncounter">
               <expression localId="22" locator="33:2-39:3" xsi:type="Union">
                  <operand localId="20" locator="34:5-37:81" xsi:type="Union">
                     <operand localId="16" locator="34:5-35:46" xsi:type="Union">
                        <operand localId="14" locator="34:5-34:31" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                           <codes locator="34:17-34:30" name="Office Visit" xsi:type="ValueSetRef"/>
                        </operand>
                        <operand localId="15" locator="35:11-35:46" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                           <codes locator="35:23-35:45" name="Annual Wellness Visit" xsi:type="ValueSetRef"/>
                        </operand>
                     </operand>
                     <operand xsi:type="Union">
                        <operand localId="17" locator="36:11-36:87" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                           <codes locator="36:23-36:86" name="Preventive Care Services - Established Office Visit, 18 and Up" xsi:type="ValueSetRef"/>
                        </operand>
                        <operand localId="19" locator="37:11-37:81" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                           <codes locator="37:23-37:80" name="Preventive Care Services-Initial Office Visit, 18 and Up" xsi:type="ValueSetRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="21" locator="38:11-38:49" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/StructureDefinition/Encounter" codeProperty="type" xsi:type="Retrieve">
                     <codes locator="38:23-38:48" name="Home Healthcare Services" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="32" locator="40:3-41:43" xsi:type="And">
               <operand localId="27" locator="40:9-40:57" xsi:type="IncludedIn">
                  <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="25" locator="40:9-40:29" path="period" scope="ValidEncounter" xsi:type="Property"/>
                  </operand>
                  <operand localId="26" locator="40:38-40:57" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
               <operand localId="31" locator="41:9-41:43" xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="29" locator="41:9-41:29" path="status" scope="ValidEncounter" xsi:type="Property"/>
                  </operand>
                  <operand localId="30" locator="41:34-41:43" valueType="t:String" value="finished" xsi:type="Literal"/>
               </operand>
            </where>
         </expression>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      } ],
      "identifier" : {
         "id" : "AdultOutpatientEncounters",
         "system" : "http://fhir.org/guides/dbcg/connectathon",
         "version" : "2.0.000"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "17:1-17:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1"
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "2",
            "locator" : "19:1-19:54",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://hl7.org/fhir/FHIRHelpers",
            "version" : "4.0.1"
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "13",
            "locator" : "27:1-28:66",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "default" : {
               "localId" : "10",
               "locator" : "28:11-28:66",
               "lowClosed" : true,
               "highClosed" : false,
               "type" : "Interval",
               "low" : {
                  "localId" : "8",
                  "locator" : "28:20-28:41",
                  "type" : "DateTime",
                  "year" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2019",
                     "type" : "Literal"
                  },
                  "month" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "day" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "hour" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "minute" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "second" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "millisecond" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               },
               "high" : {
                  "localId" : "9",
                  "locator" : "28:44-28:65",
                  "type" : "DateTime",
                  "year" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2020",
                     "type" : "Literal"
                  },
                  "month" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "day" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "1",
                     "type" : "Literal"
                  },
                  "hour" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "minute" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "second" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  },
                  "millisecond" : {
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               }
            },
            "parameterTypeSpecifier" : {
               "localId" : "12",
               "locator" : "27:32-27:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "11",
                  "locator" : "27:41-27:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "3",
            "locator" : "21:1-21:104",
            "name" : "Office Visit",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001",
            "accessLevel" : "Public"
         }, {
            "localId" : "4",
            "locator" : "22:1-22:103",
            "name" : "Annual Wellness Visit",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240",
            "accessLevel" : "Public"
         }, {
            "localId" : "5",
            "locator" : "23:1-23:154",
            "name" : "Preventive Care Services - Established Office Visit, 18 and Up",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025",
            "accessLevel" : "Public"
         }, {
            "localId" : "6",
            "locator" : "24:1-24:148",
            "name" : "Preventive Care Services-Initial Office Visit, 18 and Up",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023",
            "accessLevel" : "Public"
         }, {
            "localId" : "7",
            "locator" : "25:1-25:116",
            "name" : "Home Healthcare Services",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016",
            "accessLevel" : "Public"
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "30:1-30:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "30:1-30:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/StructureDefinition/Patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "34",
            "locator" : "32:1-41:43",
            "name" : "Qualifying Encounters",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "34",
                  "s" : [ {
                     "value" : [ "define ","\"Qualifying Encounters\"",":\r\n\t" ]
                  }, {
                     "r" : "33",
                     "s" : [ {
                        "s" : [ {
                           "r" : "23",
                           "s" : [ {
                              "r" : "22",
                              "s" : [ {
                                 "value" : [ "(\r\n    " ]
                              }, {
                                 "r" : "22",
                                 "s" : [ {
                                    "r" : "20",
                                    "s" : [ {
                                       "r" : "18",
                                       "s" : [ {
                                          "r" : "16",
                                          "s" : [ {
                                             "r" : "14",
                                             "s" : [ {
                                                "value" : [ "[","Encounter",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Office Visit\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          }, {
                                             "value" : [ "\r\n  \t\tunion " ]
                                          }, {
                                             "r" : "15",
                                             "s" : [ {
                                                "value" : [ "[","Encounter",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Annual Wellness Visit\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\r\n  \t\tunion " ]
                                       }, {
                                          "r" : "17",
                                          "s" : [ {
                                             "value" : [ "[","Encounter",": " ]
                                          }, {
                                             "s" : [ {
                                                "value" : [ "\"Preventive Care Services - Established Office Visit, 18 and Up\"" ]
                                             } ]
                                          }, {
                                             "value" : [ "]" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\r\n  \t\tunion " ]
                                    }, {
                                       "r" : "19",
                                       "s" : [ {
                                          "value" : [ "[","Encounter",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Preventive Care Services-Initial Office Visit, 18 and Up\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\r\n  \t\tunion " ]
                                 }, {
                                    "r" : "21",
                                    "s" : [ {
                                       "value" : [ "[","Encounter",": " ]
                                    }, {
                                       "s" : [ {
                                          "value" : [ "\"Home Healthcare Services\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\r\n  )" ]
                              } ]
                           }, {
                              "value" : [ " ","ValidEncounter" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\r\n\t\t" ]
                     }, {
                        "r" : "32",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "32",
                           "s" : [ {
                              "r" : "27",
                              "s" : [ {
                                 "r" : "25",
                                 "s" : [ {
                                    "r" : "24",
                                    "s" : [ {
                                       "value" : [ "ValidEncounter" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "25",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "27",
                                 "value" : [ " ","during"," " ]
                              }, {
                                 "r" : "26",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n  \t\tand " ]
                           }, {
                              "r" : "31",
                              "s" : [ {
                                 "r" : "29",
                                 "s" : [ {
                                    "r" : "28",
                                    "s" : [ {
                                       "value" : [ "ValidEncounter" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "29",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "  ","="," " ]
                              }, {
                                 "r" : "30",
                                 "s" : [ {
                                    "value" : [ "'finished'" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "33",
               "locator" : "33:2-41:43",
               "type" : "Query",
               "source" : [ {
                  "localId" : "23",
                  "locator" : "33:2-39:18",
                  "alias" : "ValidEncounter",
                  "expression" : {
                     "localId" : "22",
                     "locator" : "33:2-39:3",
                     "type" : "Union",
                     "operand" : [ {
                        "localId" : "20",
                        "locator" : "34:5-37:81",
                        "type" : "Union",
                        "operand" : [ {
                           "localId" : "16",
                           "locator" : "34:5-35:46",
                           "type" : "Union",
                           "operand" : [ {
                              "localId" : "14",
                              "locator" : "34:5-34:31",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                              "codeProperty" : "type",
                              "type" : "Retrieve",
                              "codes" : {
                                 "locator" : "34:17-34:30",
                                 "name" : "Office Visit",
                                 "type" : "ValueSetRef"
                              }
                           }, {
                              "localId" : "15",
                              "locator" : "35:11-35:46",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                              "codeProperty" : "type",
                              "type" : "Retrieve",
                              "codes" : {
                                 "locator" : "35:23-35:45",
                                 "name" : "Annual Wellness Visit",
                                 "type" : "ValueSetRef"
                              }
                           } ]
                        }, {
                           "type" : "Union",
                           "operand" : [ {
                              "localId" : "17",
                              "locator" : "36:11-36:87",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                              "codeProperty" : "type",
                              "type" : "Retrieve",
                              "codes" : {
                                 "locator" : "36:23-36:86",
                                 "name" : "Preventive Care Services - Established Office Visit, 18 and Up",
                                 "type" : "ValueSetRef"
                              }
                           }, {
                              "localId" : "19",
                              "locator" : "37:11-37:81",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                              "codeProperty" : "type",
                              "type" : "Retrieve",
                              "codes" : {
                                 "locator" : "37:23-37:80",
                                 "name" : "Preventive Care Services-Initial Office Visit, 18 and Up",
                                 "type" : "ValueSetRef"
                              }
                           } ]
                        } ]
                     }, {
                        "localId" : "21",
                        "locator" : "38:11-38:49",
                        "dataType" : "{http://hl7.org/fhir}Encounter",
                        "templateId" : "http://hl7.org/fhir/StructureDefinition/Encounter",
                        "codeProperty" : "type",
                        "type" : "Retrieve",
                        "codes" : {
                           "locator" : "38:23-38:48",
                           "name" : "Home Healthcare Services",
                           "type" : "ValueSetRef"
                        }
                     } ]
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "32",
                  "locator" : "40:3-41:43",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "27",
                     "locator" : "40:9-40:57",
                     "type" : "IncludedIn",
                     "operand" : [ {
                        "name" : "ToInterval",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "25",
                           "locator" : "40:9-40:29",
                           "path" : "period",
                           "scope" : "ValidEncounter",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "26",
                        "locator" : "40:38-40:57",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     } ]
                  }, {
                     "localId" : "31",
                     "locator" : "41:9-41:43",
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "29",
                           "locator" : "41:9-41:29",
                           "path" : "status",
                           "scope" : "ValidEncounter",
                           "type" : "Property"
                        } ]
                     }, {
                        "localId" : "30",
                        "locator" : "41:34-41:43",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "finished",
                        "type" : "Literal"
                     } ]
                  } ]
               }
            }
         } ]
      }
   }
}" + } ] + }, + "request": { + "method": "PUT", + "url": "Library/library-AdultOutpatientEncounters-2.0.000" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.464.1003.108.12.1039", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1039", + "identifier": [ { + "system": "urn:ietf:rfc:3986", + "value": "2.16.840.1.113883.3.464.1003.108.12.1039" + } ], + "version": "20171219", + "name": "FITDNA", + "title": "FIT DNA", + "status": "active", + "publisher": "NLM", + "compose": { + "include": [ { + "system": "http://loinc.org", + "version": "2.64", + "concept": [ { + "code": "77353-1", + "display": "Noninvasive colorectal cancer DNA and occult blood screening [Interpretation] in Stool Narrative" + }, { + "code": "77354-9", + "display": "Noninvasive colorectal cancer DNA and occult blood screening [Presence] in Stool" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.464.1003.108.12.1039" + } + }, { + "resource": { + "resourceType": "ValueSet", + "id": "2.16.840.1.113883.3.117.1.7.1.292", + "url": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.117.1.7.1.292", + "title": "Emergency Department Visit", + "status": "active", + "publisher": "The Joint Commission", + "compose": { + "include": [ { + "system": "http://snomed.info/sct", + "version": "2019-03", + "concept": [ { + "code": "4525004", + "display": "Emergency department patient visit (procedure)" + } ] + } ] + } + }, + "request": { + "method": "PUT", + "url": "ValueSet/2.16.840.1.113883.3.117.1.7.1.292" + } + }, { + "resource": { + "resourceType": "Library", + "id": "FHIR-ModelInfo", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "#cqf-tooling" + } + } ], + "url": "http://hl7.org/fhir/Library/FHIR-ModelInfo", + "identifier": [ { + "use": "official", + "system": "http://example.org/fhir/cqi/ecqm/Library/Identifier", + "value": "FHIR" + } ], + "version": "4.0.1", + "name": "FHIR", + "title": "FHIR Model Definition", + "status": "active", + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "model-definition" + } ] + }, + "date": "2019-08-08", + "publisher": "Health Level 7 International - Clinical Quality Information Work Group", + "contact": [ { + "telecom": [ { + "system": "url", + "value": "http://www.hl7.org/Special/committees/cqi/index.cfm" + } ] + } ], + "description": "Model definition for the FHIR R4 (v4.0.1) Model", + "jurisdiction": [ { + "coding": [ { + "system": "http://unstats.un.org/unsd/methods/m49/m49.htm", + "code": "001" + } ] + } ], + "approvalDate": "2019-08-08", + "lastReviewDate": "2020-06-19", + "topic": [ { + "text": "FHIR" + } ], + "content": [ { + "contentType": "application/xml", + "url": "https://github.com/cqframework/clinical_quality_language/blob/master/Src/java/quick/src/main/resources/org/hl7/fhir/fhir-modelinfo-4.0.1.xml" + } ] + }, + "request": { + "method": "PUT", + "url": "Library/FHIR-ModelInfo" + } + }, { + "resource": { + "resourceType": "Patient", + "id": "numer-EXM130", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, + "extension": [ { + "url": "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race", + "extension": [ { + "url": "ombCategory", + "valueCoding": { + "system": "urn:oid:2.16.840.1.113883.6.238", + "code": "2028-9", + "display": "Asian" + } + } ] + }, { + "url": "http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity", + "extension": [ { + "url": "ombCategory", + "valueCoding": { + "system": "urn:oid:2.16.840.1.113883.6.238", + "code": "2135-2", + "display": "Hispanic or Latino" + } + } ] + } ], + "identifier": [ { + "use": "usual", + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/v2-0203", + "code": "MR", + "display": "Medical Record Number" + } ] + }, + "system": "http://hospital.smarthealthit.org", + "value": "999999992" + } ], + "name": [ { + "family": "Blitz", + "given": [ "Don" ] + } ], + "gender": "male", + "birthDate": "1965-01-01" + }, + "request": { + "method": "PUT", + "url": "Patient/numer-EXM130" + } + }, { + "resource": { + "resourceType": "Library", + "id": "library-FHIRHelpers-4.0.1", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "#cqf-tooling" + } + } ], + "url": "http://hl7.org/fhir/Library/FHIRHelpers", + "version": "4.0.1", + "name": "FHIRHelpers", + "status": "active", + "experimental": true, + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } ] + }, + "relatedArtifact": [ { + "type": "depends-on", + "resource": "http://hl7.org/fhir/Library/FHIR-ModelInfo|4.0.1" + } ], + "content": [ { + "contentType": "text/cql", + "data": "library FHIRHelpers version '4.0.1'

using FHIR version '4.0.1'

define function ToInterval(period FHIR.Period):
    if period is null then
        null
    else
        Interval[period."start".value, period."end".value]

define function ToQuantity(quantity FHIR.Quantity):
    if quantity is null then
        null
    else
        System.Quantity { value: quantity.value.value, unit: quantity.unit.value }

define function ToInterval(range FHIR.Range):
    if range is null then
        null
    else
        Interval[ToQuantity(range.low), ToQuantity(range.high)]

define function ToCode(coding FHIR.Coding):
    if coding is null then
        null
    else
        System.Code {
          code: coding.code.value,
          system: coding.system.value,
          version: coding.version.value,
          display: coding.display.value
        }

define function ToConcept(concept FHIR.CodeableConcept):
    if concept is null then
        null
    else
        System.Concept {
            codes: concept.coding C return ToCode(C),
            display: concept.text.value
        }


define function ToString(value AccountStatus): value.value
define function ToString(value ActionCardinalityBehavior): value.value
define function ToString(value ActionConditionKind): value.value
define function ToString(value ActionGroupingBehavior): value.value
define function ToString(value ActionParticipantType): value.value
define function ToString(value ActionPrecheckBehavior): value.value
define function ToString(value ActionRelationshipType): value.value
define function ToString(value ActionRequiredBehavior): value.value
define function ToString(value ActionSelectionBehavior): value.value
define function ToString(value ActivityDefinitionKind): value.value
define function ToString(value ActivityParticipantType): value.value
define function ToString(value AddressType): value.value
define function ToString(value AddressUse): value.value
define function ToString(value AdministrativeGender): value.value
define function ToString(value AdverseEventActuality): value.value
define function ToString(value AggregationMode): value.value
define function ToString(value AllergyIntoleranceCategory): value.value
define function ToString(value AllergyIntoleranceCriticality): value.value
define function ToString(value AllergyIntoleranceSeverity): value.value
define function ToString(value AllergyIntoleranceType): value.value
define function ToString(value AppointmentStatus): value.value
define function ToString(value AssertionDirectionType): value.value
define function ToString(value AssertionOperatorType): value.value
define function ToString(value AssertionResponseTypes): value.value
define function ToString(value AuditEventAction): value.value
define function ToString(value AuditEventAgentNetworkType): value.value
define function ToString(value AuditEventOutcome): value.value
define function ToString(value BindingStrength): value.value
define function ToString(value BiologicallyDerivedProductCategory): value.value
define function ToString(value BiologicallyDerivedProductStatus): value.value
define function ToString(value BiologicallyDerivedProductStorageScale): value.value
define function ToString(value BundleType): value.value
define function ToString(value CapabilityStatementKind): value.value
define function ToString(value CarePlanActivityKind): value.value
define function ToString(value CarePlanActivityStatus): value.value
define function ToString(value CarePlanIntent): value.value
define function ToString(value CarePlanStatus): value.value
define function ToString(value CareTeamStatus): value.value
define function ToString(value CatalogEntryRelationType): value.value
define function ToString(value ChargeItemDefinitionPriceComponentType): value.value
define function ToString(value ChargeItemStatus): value.value
define function ToString(value ClaimResponseStatus): value.value
define function ToString(value ClaimStatus): value.value
define function ToString(value ClinicalImpressionStatus): value.value
define function ToString(value CodeSearchSupport): value.value
define function ToString(value CodeSystemContentMode): value.value
define function ToString(value CodeSystemHierarchyMeaning): value.value
define function ToString(value CommunicationPriority): value.value
define function ToString(value CommunicationRequestStatus): value.value
define function ToString(value CommunicationStatus): value.value
define function ToString(value CompartmentCode): value.value
define function ToString(value CompartmentType): value.value
define function ToString(value CompositionAttestationMode): value.value
define function ToString(value CompositionStatus): value.value
define function ToString(value ConceptMapEquivalence): value.value
define function ToString(value ConceptMapGroupUnmappedMode): value.value
define function ToString(value ConditionalDeleteStatus): value.value
define function ToString(value ConditionalReadStatus): value.value
define function ToString(value ConsentDataMeaning): value.value
define function ToString(value ConsentProvisionType): value.value
define function ToString(value ConsentState): value.value
define function ToString(value ConstraintSeverity): value.value
define function ToString(value ContactPointSystem): value.value
define function ToString(value ContactPointUse): value.value
define function ToString(value ContractPublicationStatus): value.value
define function ToString(value ContractStatus): value.value
define function ToString(value ContributorType): value.value
define function ToString(value CoverageStatus): value.value
define function ToString(value CurrencyCode): value.value
define function ToString(value DayOfWeek): value.value
define function ToString(value DaysOfWeek): value.value
define function ToString(value DetectedIssueSeverity): value.value
define function ToString(value DetectedIssueStatus): value.value
define function ToString(value DeviceMetricCalibrationState): value.value
define function ToString(value DeviceMetricCalibrationType): value.value
define function ToString(value DeviceMetricCategory): value.value
define function ToString(value DeviceMetricColor): value.value
define function ToString(value DeviceMetricOperationalStatus): value.value
define function ToString(value DeviceNameType): value.value
define function ToString(value DeviceRequestStatus): value.value
define function ToString(value DeviceUseStatementStatus): value.value
define function ToString(value DiagnosticReportStatus): value.value
define function ToString(value DiscriminatorType): value.value
define function ToString(value DocumentConfidentiality): value.value
define function ToString(value DocumentMode): value.value
define function ToString(value DocumentReferenceStatus): value.value
define function ToString(value DocumentRelationshipType): value.value
define function ToString(value EligibilityRequestPurpose): value.value
define function ToString(value EligibilityRequestStatus): value.value
define function ToString(value EligibilityResponsePurpose): value.value
define function ToString(value EligibilityResponseStatus): value.value
define function ToString(value EnableWhenBehavior): value.value
define function ToString(value EncounterLocationStatus): value.value
define function ToString(value EncounterStatus): value.value
define function ToString(value EndpointStatus): value.value
define function ToString(value EnrollmentRequestStatus): value.value
define function ToString(value EnrollmentResponseStatus): value.value
define function ToString(value EpisodeOfCareStatus): value.value
define function ToString(value EventCapabilityMode): value.value
define function ToString(value EventTiming): value.value
define function ToString(value EvidenceVariableType): value.value
define function ToString(value ExampleScenarioActorType): value.value
define function ToString(value ExplanationOfBenefitStatus): value.value
define function ToString(value ExposureState): value.value
define function ToString(value ExtensionContextType): value.value
define function ToString(value FHIRAllTypes): value.value
define function ToString(value FHIRDefinedType): value.value
define function ToString(value FHIRDeviceStatus): value.value
define function ToString(value FHIRResourceType): value.value
define function ToString(value FHIRSubstanceStatus): value.value
define function ToString(value FHIRVersion): value.value
define function ToString(value FamilyHistoryStatus): value.value
define function ToString(value FilterOperator): value.value
define function ToString(value FlagStatus): value.value
define function ToString(value GoalLifecycleStatus): value.value
define function ToString(value GraphCompartmentRule): value.value
define function ToString(value GraphCompartmentUse): value.value
define function ToString(value GroupMeasure): value.value
define function ToString(value GroupType): value.value
define function ToString(value GuidanceResponseStatus): value.value
define function ToString(value GuidePageGeneration): value.value
define function ToString(value GuideParameterCode): value.value
define function ToString(value HTTPVerb): value.value
define function ToString(value IdentifierUse): value.value
define function ToString(value IdentityAssuranceLevel): value.value
define function ToString(value ImagingStudyStatus): value.value
define function ToString(value ImmunizationEvaluationStatus): value.value
define function ToString(value ImmunizationStatus): value.value
define function ToString(value InvoicePriceComponentType): value.value
define function ToString(value InvoiceStatus): value.value
define function ToString(value IssueSeverity): value.value
define function ToString(value IssueType): value.value
define function ToString(value LinkType): value.value
define function ToString(value LinkageType): value.value
define function ToString(value ListMode): value.value
define function ToString(value ListStatus): value.value
define function ToString(value LocationMode): value.value
define function ToString(value LocationStatus): value.value
define function ToString(value MeasureReportStatus): value.value
define function ToString(value MeasureReportType): value.value
define function ToString(value MediaStatus): value.value
define function ToString(value MedicationAdministrationStatus): value.value
define function ToString(value MedicationDispenseStatus): value.value
define function ToString(value MedicationKnowledgeStatus): value.value
define function ToString(value MedicationRequestIntent): value.value
define function ToString(value MedicationRequestPriority): value.value
define function ToString(value MedicationRequestStatus): value.value
define function ToString(value MedicationStatementStatus): value.value
define function ToString(value MedicationStatus): value.value
define function ToString(value MessageSignificanceCategory): value.value
define function ToString(value Messageheader_Response_Request): value.value
define function ToString(value MimeType): value.value
define function ToString(value NameUse): value.value
define function ToString(value NamingSystemIdentifierType): value.value
define function ToString(value NamingSystemType): value.value
define function ToString(value NarrativeStatus): value.value
define function ToString(value NoteType): value.value
define function ToString(value NutritiionOrderIntent): value.value
define function ToString(value NutritionOrderStatus): value.value
define function ToString(value ObservationDataType): value.value
define function ToString(value ObservationRangeCategory): value.value
define function ToString(value ObservationStatus): value.value
define function ToString(value OperationKind): value.value
define function ToString(value OperationParameterUse): value.value
define function ToString(value OrientationType): value.value
define function ToString(value ParameterUse): value.value
define function ToString(value ParticipantRequired): value.value
define function ToString(value ParticipantStatus): value.value
define function ToString(value ParticipationStatus): value.value
define function ToString(value PaymentNoticeStatus): value.value
define function ToString(value PaymentReconciliationStatus): value.value
define function ToString(value ProcedureStatus): value.value
define function ToString(value PropertyRepresentation): value.value
define function ToString(value PropertyType): value.value
define function ToString(value ProvenanceEntityRole): value.value
define function ToString(value PublicationStatus): value.value
define function ToString(value QualityType): value.value
define function ToString(value QuantityComparator): value.value
define function ToString(value QuestionnaireItemOperator): value.value
define function ToString(value QuestionnaireItemType): value.value
define function ToString(value QuestionnaireResponseStatus): value.value
define function ToString(value ReferenceHandlingPolicy): value.value
define function ToString(value ReferenceVersionRules): value.value
define function ToString(value ReferredDocumentStatus): value.value
define function ToString(value RelatedArtifactType): value.value
define function ToString(value RemittanceOutcome): value.value
define function ToString(value RepositoryType): value.value
define function ToString(value RequestIntent): value.value
define function ToString(value RequestPriority): value.value
define function ToString(value RequestStatus): value.value
define function ToString(value ResearchElementType): value.value
define function ToString(value ResearchStudyStatus): value.value
define function ToString(value ResearchSubjectStatus): value.value
define function ToString(value ResourceType): value.value
define function ToString(value ResourceVersionPolicy): value.value
define function ToString(value ResponseType): value.value
define function ToString(value RestfulCapabilityMode): value.value
define function ToString(value RiskAssessmentStatus): value.value
define function ToString(value SPDXLicense): value.value
define function ToString(value SearchComparator): value.value
define function ToString(value SearchEntryMode): value.value
define function ToString(value SearchModifierCode): value.value
define function ToString(value SearchParamType): value.value
define function ToString(value SectionMode): value.value
define function ToString(value SequenceType): value.value
define function ToString(value ServiceRequestIntent): value.value
define function ToString(value ServiceRequestPriority): value.value
define function ToString(value ServiceRequestStatus): value.value
define function ToString(value SlicingRules): value.value
define function ToString(value SlotStatus): value.value
define function ToString(value SortDirection): value.value
define function ToString(value SpecimenContainedPreference): value.value
define function ToString(value SpecimenStatus): value.value
define function ToString(value Status): value.value
define function ToString(value StrandType): value.value
define function ToString(value StructureDefinitionKind): value.value
define function ToString(value StructureMapContextType): value.value
define function ToString(value StructureMapGroupTypeMode): value.value
define function ToString(value StructureMapInputMode): value.value
define function ToString(value StructureMapModelMode): value.value
define function ToString(value StructureMapSourceListMode): value.value
define function ToString(value StructureMapTargetListMode): value.value
define function ToString(value StructureMapTransform): value.value
define function ToString(value SubscriptionChannelType): value.value
define function ToString(value SubscriptionStatus): value.value
define function ToString(value SupplyDeliveryStatus): value.value
define function ToString(value SupplyRequestStatus): value.value
define function ToString(value SystemRestfulInteraction): value.value
define function ToString(value TaskIntent): value.value
define function ToString(value TaskPriority): value.value
define function ToString(value TaskStatus): value.value
define function ToString(value TestReportActionResult): value.value
define function ToString(value TestReportParticipantType): value.value
define function ToString(value TestReportResult): value.value
define function ToString(value TestReportStatus): value.value
define function ToString(value TestScriptRequestMethodCode): value.value
define function ToString(value TriggerType): value.value
define function ToString(value TypeDerivationRule): value.value
define function ToString(value TypeRestfulInteraction): value.value
define function ToString(value UDIEntryType): value.value
define function ToString(value UnitsOfTime): value.value
define function ToString(value Use): value.value
define function ToString(value VariableType): value.value
define function ToString(value VisionBase): value.value
define function ToString(value VisionEyes): value.value
define function ToString(value VisionStatus): value.value
define function ToString(value XPathUsageType): value.value
define function ToString(value base64Binary): value.value
define function ToBoolean(value boolean): value.value
define function ToDate(value date): value.value
define function ToDateTime(value dateTime): value.value
define function ToDecimal(value decimal): value.value
define function ToDateTime(value instant): value.value
define function ToInteger(value integer): value.value
define function ToString(value string): value.value
define function ToTime(value time): value.value
define function ToString(value uri): value.value
define function ToString(value xhtml): value.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 translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <identifier id="FHIRHelpers" system="http://fhir.org/guides/dbcg/connectathon" version="4.0.1"/>
   <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:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1"/>
   </usings>
   <statements>
      <def localId="14" locator="5:1-9:58" name="ToInterval" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="14">
               <a:s>define function ToInterval(period </a:s>
               <a:s r="2">
                  <a:s>FHIR.Period</a:s>
               </a:s>
               <a:s>):&#xd;
    </a:s>
               <a:s r="13">
                  <a:s r="13">
                     <a:s>if </a:s>
                     <a:s r="4">
                        <a:s r="3">
                           <a:s>period</a:s>
                        </a:s>
                        <a:s> is null</a:s>
                     </a:s>
                     <a:s r="5"> then&#xd;
        null&#xd;
    else&#xd;
        </a:s>
                     <a:s r="12">
                        <a:s>Interval[</a:s>
                        <a:s r="8">
                           <a:s r="7">
                              <a:s r="6">
                                 <a:s>period</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="7">
                                 <a:s>&quot;start&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="8">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="11">
                           <a:s r="10">
                              <a:s r="9">
                                 <a:s>period</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="10">
                                 <a:s>&quot;end&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="11">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s>]</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="13" locator="6:5-9:58" xsi:type="If">
            <condition asType="t:Boolean" xsi:type="As">
               <operand localId="4" locator="6:8-6:21" xsi:type="IsNull">
                  <operand localId="3" locator="6:8-6:13" name="period" xsi:type="OperandRef"/>
               </operand>
            </condition>
            <then xsi:type="As">
               <operand localId="5" locator="7:9-7:12" xsi:type="Null"/>
               <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                  <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </asTypeSpecifier>
            </then>
            <else localId="12" locator="9:9-9:58" lowClosed="true" highClosed="true" xsi:type="Interval">
               <low localId="8" locator="9:18-9:37" path="value" xsi:type="Property">
                  <source localId="7" locator="9:18-9:31" path="start" xsi:type="Property">
                     <source localId="6" locator="9:18-9:23" name="period" xsi:type="OperandRef"/>
                  </source>
               </low>
               <high localId="11" locator="9:40-9:57" path="value" xsi:type="Property">
                  <source localId="10" locator="9:40-9:51" path="end" xsi:type="Property">
                     <source localId="9" locator="9:40-9:45" name="period" xsi:type="OperandRef"/>
                  </source>
               </high>
            </else>
         </expression>
         <operand name="period">
            <operandTypeSpecifier localId="2" locator="5:35-5:45" name="fhir:Period" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="27" locator="11:1-15:82" name="ToQuantity" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="27">
               <a:s>define function ToQuantity(quantity </a:s>
               <a:s r="15">
                  <a:s>FHIR.Quantity</a:s>
               </a:s>
               <a:s>):&#xd;
    </a:s>
               <a:s r="26">
                  <a:s r="26">
                     <a:s>if </a:s>
                     <a:s r="17">
                        <a:s r="16">
                           <a:s>quantity</a:s>
                        </a:s>
                        <a:s> is null</a:s>
                     </a:s>
                     <a:s r="18"> then&#xd;
        null&#xd;
    else&#xd;
        </a:s>
                     <a:s r="25">
                        <a:s>System.Quantity { </a:s>
                        <a:s>
                           <a:s>value: </a:s>
                           <a:s r="21">
                              <a:s r="20">
                                 <a:s r="19">
                                    <a:s>quantity</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 r="21">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s>
                           <a:s>unit: </a:s>
                           <a:s r="24">
                              <a:s r="23">
                                 <a:s r="22">
                                    <a:s>quantity</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="23">
                                    <a:s>unit</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="24">
                                 <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="26" locator="12:5-15:82" xsi:type="If">
            <condition asType="t:Boolean" xsi:type="As">
               <operand localId="17" locator="12:8-12:23" xsi:type="IsNull">
                  <operand localId="16" locator="12:8-12:15" name="quantity" xsi:type="OperandRef"/>
               </operand>
            </condition>
            <then asType="t:Quantity" xsi:type="As">
               <operand localId="18" locator="13:9-13:12" xsi:type="Null"/>
            </then>
            <else localId="25" locator="15:9-15:82" classType="t:Quantity" xsi:type="Instance">
               <element name="value">
                  <value localId="21" locator="15:34-15:53" path="value" xsi:type="Property">
                     <source localId="20" locator="15:34-15:47" path="value" xsi:type="Property">
                        <source localId="19" locator="15:34-15:41" name="quantity" xsi:type="OperandRef"/>
                     </source>
                  </value>
               </element>
               <element name="unit">
                  <value localId="24" locator="15:62-15:80" path="value" xsi:type="Property">
                     <source localId="23" locator="15:62-15:74" path="unit" xsi:type="Property">
                        <source localId="22" locator="15:62-15:69" name="quantity" xsi:type="OperandRef"/>
                     </source>
                  </value>
               </element>
            </else>
         </expression>
         <operand name="quantity">
            <operandTypeSpecifier localId="15" locator="11:37-11:49" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="40" locator="17:1-21:63" name="ToInterval" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="40">
               <a:s>define function ToInterval(range </a:s>
               <a:s r="28">
                  <a:s>FHIR.Range</a:s>
               </a:s>
               <a:s>):&#xd;
    </a:s>
               <a:s r="39">
                  <a:s r="39">
                     <a:s>if </a:s>
                     <a:s r="30">
                        <a:s r="29">
                           <a:s>range</a:s>
                        </a:s>
                        <a:s> is null</a:s>
                     </a:s>
                     <a:s r="31"> then&#xd;
        null&#xd;
    else&#xd;
        </a:s>
                     <a:s r="38">
                        <a:s>Interval[</a:s>
                        <a:s r="34">
                           <a:s>ToQuantity(</a:s>
                           <a:s r="33">
                              <a:s r="32">
                                 <a:s>range</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="33">
                                 <a:s>low</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="37">
                           <a:s>ToQuantity(</a:s>
                           <a:s r="36">
                              <a:s r="35">
                                 <a:s>range</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="36">
                                 <a:s>high</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="18:5-21:63" xsi:type="If">
            <condition asType="t:Boolean" xsi:type="As">
               <operand localId="30" locator="18:8-18:20" xsi:type="IsNull">
                  <operand localId="29" locator="18:8-18:12" name="range" xsi:type="OperandRef"/>
               </operand>
            </condition>
            <then xsi:type="As">
               <operand localId="31" locator="19:9-19:12" xsi:type="Null"/>
               <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                  <pointType name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
               </asTypeSpecifier>
            </then>
            <else localId="38" locator="21:9-21:63" lowClosed="true" highClosed="true" xsi:type="Interval">
               <low localId="34" locator="21:18-21:38" name="ToQuantity" xsi:type="FunctionRef">
                  <operand localId="33" locator="21:29-21:37" path="low" xsi:type="Property">
                     <source localId="32" locator="21:29-21:33" name="range" xsi:type="OperandRef"/>
                  </operand>
               </low>
               <high localId="37" locator="21:41-21:62" name="ToQuantity" xsi:type="FunctionRef">
                  <operand localId="36" locator="21:52-21:61" path="high" xsi:type="Property">
                     <source localId="35" locator="21:52-21:56" name="range" xsi:type="OperandRef"/>
                  </operand>
               </high>
            </else>
         </expression>
         <operand name="range">
            <operandTypeSpecifier localId="28" locator="17:34-17:43" name="fhir:Range" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="59" locator="23:1-32:9" name="ToCode" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="59">
               <a:s>define function ToCode(coding </a:s>
               <a:s r="41">
                  <a:s>FHIR.Coding</a:s>
               </a:s>
               <a:s>):&#xd;
    </a:s>
               <a:s r="58">
                  <a:s r="58">
                     <a:s>if </a:s>
                     <a:s r="43">
                        <a:s r="42">
                           <a:s>coding</a:s>
                        </a:s>
                        <a:s> is null</a:s>
                     </a:s>
                     <a:s r="44"> then&#xd;
        null&#xd;
    else&#xd;
        </a:s>
                     <a:s r="57">
                        <a:s>System.Code {&#xd;
          </a:s>
                        <a:s>
                           <a:s>code: </a:s>
                           <a:s r="47">
                              <a:s r="46">
                                 <a:s r="45">
                                    <a:s>coding</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="46">
                                    <a:s>code</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="47">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,&#xd;
          </a:s>
                        <a:s>
                           <a:s>system: </a:s>
                           <a:s r="50">
                              <a:s r="49">
                                 <a:s r="48">
                                    <a:s>coding</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="49">
                                    <a:s>system</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="50">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,&#xd;
          </a:s>
                        <a:s>
                           <a:s>version: </a:s>
                           <a:s r="53">
                              <a:s r="52">
                                 <a:s r="51">
                                    <a:s>coding</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="52">
                                    <a:s>version</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>
                        <a:s>,&#xd;
          </a:s>
                        <a:s>
                           <a:s>display: </a:s>
                           <a:s r="56">
                              <a:s r="55">
                                 <a:s r="54">
                                    <a:s>coding</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="55">
                                    <a:s>display</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="56">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
        }</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="58" locator="24:5-32:9" xsi:type="If">
            <condition asType="t:Boolean" xsi:type="As">
               <operand localId="43" locator="24:8-24:21" xsi:type="IsNull">
                  <operand localId="42" locator="24:8-24:13" name="coding" xsi:type="OperandRef"/>
               </operand>
            </condition>
            <then asType="t:Code" xsi:type="As">
               <operand localId="44" locator="25:9-25:12" xsi:type="Null"/>
            </then>
            <else localId="57" locator="27:9-32:9" classType="t:Code" xsi:type="Instance">
               <element name="code">
                  <value localId="47" locator="28:17-28:33" path="value" xsi:type="Property">
                     <source localId="46" locator="28:17-28:27" path="code" xsi:type="Property">
                        <source localId="45" locator="28:17-28:22" name="coding" xsi:type="OperandRef"/>
                     </source>
                  </value>
               </element>
               <element name="system">
                  <value localId="50" locator="29:19-29:37" path="value" xsi:type="Property">
                     <source localId="49" locator="29:19-29:31" path="system" xsi:type="Property">
                        <source localId="48" locator="29:19-29:24" name="coding" xsi:type="OperandRef"/>
                     </source>
                  </value>
               </element>
               <element name="version">
                  <value localId="53" locator="30:20-30:39" path="value" xsi:type="Property">
                     <source localId="52" locator="30:20-30:33" path="version" xsi:type="Property">
                        <source localId="51" locator="30:20-30:25" name="coding" xsi:type="OperandRef"/>
                     </source>
                  </value>
               </element>
               <element name="display">
                  <value localId="56" locator="31:20-31:39" path="value" xsi:type="Property">
                     <source localId="55" locator="31:20-31:33" path="display" xsi:type="Property">
                        <source localId="54" locator="31:20-31:25" name="coding" xsi:type="OperandRef"/>
                     </source>
                  </value>
               </element>
            </else>
         </expression>
         <operand name="coding">
            <operandTypeSpecifier localId="41" locator="23:31-23:41" name="fhir:Coding" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="75" locator="34:1-41:9" name="ToConcept" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="75">
               <a:s>define function ToConcept(concept </a:s>
               <a:s r="60">
                  <a:s>FHIR.CodeableConcept</a:s>
               </a:s>
               <a:s>):&#xd;
    </a:s>
               <a:s r="74">
                  <a:s r="74">
                     <a:s>if </a:s>
                     <a:s r="62">
                        <a:s r="61">
                           <a:s>concept</a:s>
                        </a:s>
                        <a:s> is null</a:s>
                     </a:s>
                     <a:s r="63"> then&#xd;
        null&#xd;
    else&#xd;
        </a:s>
                     <a:s r="73">
                        <a:s>System.Concept {&#xd;
            </a:s>
                        <a:s>
                           <a:s>codes: </a:s>
                           <a:s r="69">
                              <a:s>
                                 <a:s r="65">
                                    <a:s r="64">
                                       <a:s>
                                          <a:s>concept.coding</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> C</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>ToCode(</a:s>
                                    <a:s r="66">
                                       <a:s>C</a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,&#xd;
            </a:s>
                        <a:s>
                           <a:s>display: </a:s>
                           <a:s r="72">
                              <a:s r="71">
                                 <a:s r="70">
                                    <a:s>concept</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="71">
                                    <a:s>text</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="72">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>&#xd;
        }</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="74" locator="35:5-41:9" xsi:type="If">
            <condition asType="t:Boolean" xsi:type="As">
               <operand localId="62" locator="35:8-35:22" xsi:type="IsNull">
                  <operand localId="61" locator="35:8-35:14" name="concept" xsi:type="OperandRef"/>
               </operand>
            </condition>
            <then asType="t:Concept" xsi:type="As">
               <operand localId="63" locator="36:9-36:12" xsi:type="Null"/>
            </then>
            <else localId="73" locator="38:9-41:9" classType="t:Concept" xsi:type="Instance">
               <element name="codes">
                  <value localId="69" locator="39:20-39:52" xsi:type="Query">
                     <source localId="65" locator="39:20-39:35" alias="C">
                        <expression localId="64" locator="39:20-39:33" path="coding" xsi:type="Property">
                           <source name="concept" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return localId="68" locator="39:37-39:52">
                        <expression localId="67" locator="39:44-39:52" name="ToCode" xsi:type="FunctionRef">
                           <operand localId="66" locator="39:51" name="C" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </value>
               </element>
               <element name="display">
                  <value localId="72" locator="40:22-40:39" path="value" xsi:type="Property">
                     <source localId="71" locator="40:22-40:33" path="text" xsi:type="Property">
                        <source localId="70" locator="40:22-40:28" name="concept" xsi:type="OperandRef"/>
                     </source>
                  </value>
               </element>
            </else>
         </expression>
         <operand name="concept">
            <operandTypeSpecifier localId="60" locator="34:35-34:54" name="fhir:CodeableConcept" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="79" locator="44:1-44:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="79">
               <a:s>define function ToString(value </a:s>
               <a:s r="76">
                  <a:s>AccountStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="78">
                  <a:s r="78">
                     <a:s r="77">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="78">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="78" locator="44:48-44:58" path="value" xsi:type="Property">
            <source localId="77" locator="44:48-44:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="76" locator="44:32-44:44" name="fhir:AccountStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="83" locator="45:1-45:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="83">
               <a:s>define function ToString(value </a:s>
               <a:s r="80">
                  <a:s>ActionCardinalityBehavior</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="82">
                  <a:s r="82">
                     <a:s r="81">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="82">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="82" locator="45:60-45:70" path="value" xsi:type="Property">
            <source localId="81" locator="45:60-45:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="80" locator="45:32-45:56" name="fhir:ActionCardinalityBehavior" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="87" locator="46:1-46:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="87">
               <a:s>define function ToString(value </a:s>
               <a:s r="84">
                  <a:s>ActionConditionKind</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="86">
                  <a:s r="86">
                     <a:s r="85">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="86">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="86" locator="46:54-46:64" path="value" xsi:type="Property">
            <source localId="85" locator="46:54-46:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="84" locator="46:32-46:50" name="fhir:ActionConditionKind" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="91" locator="47:1-47:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="91">
               <a:s>define function ToString(value </a:s>
               <a:s r="88">
                  <a:s>ActionGroupingBehavior</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="90">
                  <a:s r="90">
                     <a:s r="89">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="90">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="90" locator="47:57-47:67" path="value" xsi:type="Property">
            <source localId="89" locator="47:57-47:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="88" locator="47:32-47:53" name="fhir:ActionGroupingBehavior" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="95" locator="48:1-48:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="95">
               <a:s>define function ToString(value </a:s>
               <a:s r="92">
                  <a:s>ActionParticipantType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="94">
                  <a:s r="94">
                     <a:s r="93">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="94">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="94" locator="48:56-48:66" path="value" xsi:type="Property">
            <source localId="93" locator="48:56-48:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="92" locator="48:32-48:52" name="fhir:ActionParticipantType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="99" locator="49:1-49:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="99">
               <a:s>define function ToString(value </a:s>
               <a:s r="96">
                  <a:s>ActionPrecheckBehavior</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="98">
                  <a:s r="98">
                     <a:s r="97">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="98">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="98" locator="49:57-49:67" path="value" xsi:type="Property">
            <source localId="97" locator="49:57-49:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="96" locator="49:32-49:53" name="fhir:ActionPrecheckBehavior" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="103" locator="50:1-50:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="103">
               <a:s>define function ToString(value </a:s>
               <a:s r="100">
                  <a:s>ActionRelationshipType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="102">
                  <a:s r="102">
                     <a:s r="101">
                        <a:s>value</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>
         </annotation>
         <expression localId="102" locator="50:57-50:67" path="value" xsi:type="Property">
            <source localId="101" locator="50:57-50:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="100" locator="50:32-50:53" name="fhir:ActionRelationshipType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="107" locator="51:1-51:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="107">
               <a:s>define function ToString(value </a:s>
               <a:s r="104">
                  <a:s>ActionRequiredBehavior</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="106">
                  <a:s r="106">
                     <a:s r="105">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="106">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="106" locator="51:57-51:67" path="value" xsi:type="Property">
            <source localId="105" locator="51:57-51:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="104" locator="51:32-51:53" name="fhir:ActionRequiredBehavior" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="111" locator="52:1-52:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="111">
               <a:s>define function ToString(value </a:s>
               <a:s r="108">
                  <a:s>ActionSelectionBehavior</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="110">
                  <a:s r="110">
                     <a:s r="109">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="110">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="110" locator="52:58-52:68" path="value" xsi:type="Property">
            <source localId="109" locator="52:58-52:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="108" locator="52:32-52:54" name="fhir:ActionSelectionBehavior" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="115" locator="53:1-53:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="115">
               <a:s>define function ToString(value </a:s>
               <a:s r="112">
                  <a:s>ActivityDefinitionKind</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="114">
                  <a:s r="114">
                     <a:s r="113">
                        <a:s>value</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>
         </annotation>
         <expression localId="114" locator="53:57-53:67" path="value" xsi:type="Property">
            <source localId="113" locator="53:57-53:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="112" locator="53:32-53:53" name="fhir:ActivityDefinitionKind" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="119" locator="54:1-54:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="119">
               <a:s>define function ToString(value </a:s>
               <a:s r="116">
                  <a:s>ActivityParticipantType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="118">
                  <a:s r="118">
                     <a:s r="117">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="118">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="118" locator="54:58-54:68" path="value" xsi:type="Property">
            <source localId="117" locator="54:58-54:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="116" locator="54:32-54:54" name="fhir:ActivityParticipantType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="123" locator="55:1-55:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="123">
               <a:s>define function ToString(value </a:s>
               <a:s r="120">
                  <a:s>AddressType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="122">
                  <a:s r="122">
                     <a:s r="121">
                        <a:s>value</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>
         </annotation>
         <expression localId="122" locator="55:46-55:56" path="value" xsi:type="Property">
            <source localId="121" locator="55:46-55:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="120" locator="55:32-55:42" name="fhir:AddressType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="127" locator="56:1-56:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="127">
               <a:s>define function ToString(value </a:s>
               <a:s r="124">
                  <a:s>AddressUse</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="126">
                  <a:s r="126">
                     <a:s r="125">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="126">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="126" locator="56:45-56:55" path="value" xsi:type="Property">
            <source localId="125" locator="56:45-56:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="124" locator="56:32-56:41" name="fhir:AddressUse" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="131" locator="57:1-57:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="131">
               <a:s>define function ToString(value </a:s>
               <a:s r="128">
                  <a:s>AdministrativeGender</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="130">
                  <a:s r="130">
                     <a:s r="129">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="130">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="130" locator="57:55-57:65" path="value" xsi:type="Property">
            <source localId="129" locator="57:55-57:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="128" locator="57:32-57:51" name="fhir:AdministrativeGender" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="135" locator="58:1-58:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="135">
               <a:s>define function ToString(value </a:s>
               <a:s r="132">
                  <a:s>AdverseEventActuality</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="134">
                  <a:s r="134">
                     <a:s r="133">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="134">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="134" locator="58:56-58:66" path="value" xsi:type="Property">
            <source localId="133" locator="58:56-58:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="132" locator="58:32-58:52" name="fhir:AdverseEventActuality" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="139" locator="59:1-59:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="139">
               <a:s>define function ToString(value </a:s>
               <a:s r="136">
                  <a:s>AggregationMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="138">
                  <a:s r="138">
                     <a:s r="137">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="138">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="138" locator="59:50-59:60" path="value" xsi:type="Property">
            <source localId="137" locator="59:50-59:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="136" locator="59:32-59:46" name="fhir:AggregationMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="143" locator="60:1-60:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="143">
               <a:s>define function ToString(value </a:s>
               <a:s r="140">
                  <a:s>AllergyIntoleranceCategory</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="142">
                  <a:s r="142">
                     <a:s r="141">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="142">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="142" locator="60:61-60:71" path="value" xsi:type="Property">
            <source localId="141" locator="60:61-60:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="140" locator="60:32-60:57" name="fhir:AllergyIntoleranceCategory" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="147" locator="61:1-61:74" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="147">
               <a:s>define function ToString(value </a:s>
               <a:s r="144">
                  <a:s>AllergyIntoleranceCriticality</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="146">
                  <a:s r="146">
                     <a:s r="145">
                        <a:s>value</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>
         </annotation>
         <expression localId="146" locator="61:64-61:74" path="value" xsi:type="Property">
            <source localId="145" locator="61:64-61:68" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="144" locator="61:32-61:60" name="fhir:AllergyIntoleranceCriticality" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="151" locator="62:1-62:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="151">
               <a:s>define function ToString(value </a:s>
               <a:s r="148">
                  <a:s>AllergyIntoleranceSeverity</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="150">
                  <a:s r="150">
                     <a:s r="149">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="150">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="150" locator="62:61-62:71" path="value" xsi:type="Property">
            <source localId="149" locator="62:61-62:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="148" locator="62:32-62:57" name="fhir:AllergyIntoleranceSeverity" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="155" locator="63:1-63:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="155">
               <a:s>define function ToString(value </a:s>
               <a:s r="152">
                  <a:s>AllergyIntoleranceType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="154">
                  <a:s r="154">
                     <a:s r="153">
                        <a:s>value</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>
         </annotation>
         <expression localId="154" locator="63:57-63:67" path="value" xsi:type="Property">
            <source localId="153" locator="63:57-63:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="152" locator="63:32-63:53" name="fhir:AllergyIntoleranceType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="159" locator="64:1-64:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="159">
               <a:s>define function ToString(value </a:s>
               <a:s r="156">
                  <a:s>AppointmentStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="158">
                  <a:s r="158">
                     <a:s r="157">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="158">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="158" locator="64:52-64:62" path="value" xsi:type="Property">
            <source localId="157" locator="64:52-64:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="156" locator="64:32-64:48" name="fhir:AppointmentStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="163" locator="65:1-65:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="163">
               <a:s>define function ToString(value </a:s>
               <a:s r="160">
                  <a:s>AssertionDirectionType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="162">
                  <a:s r="162">
                     <a:s r="161">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="162">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="162" locator="65:57-65:67" path="value" xsi:type="Property">
            <source localId="161" locator="65:57-65:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="160" locator="65:32-65:53" name="fhir:AssertionDirectionType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="167" locator="66:1-66:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="167">
               <a:s>define function ToString(value </a:s>
               <a:s r="164">
                  <a:s>AssertionOperatorType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="166">
                  <a:s r="166">
                     <a:s r="165">
                        <a:s>value</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>
         </annotation>
         <expression localId="166" locator="66:56-66:66" path="value" xsi:type="Property">
            <source localId="165" locator="66:56-66:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="164" locator="66:32-66:52" name="fhir:AssertionOperatorType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="171" locator="67:1-67:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="171">
               <a:s>define function ToString(value </a:s>
               <a:s r="168">
                  <a:s>AssertionResponseTypes</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="170">
                  <a:s r="170">
                     <a:s r="169">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="170">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="170" locator="67:57-67:67" path="value" xsi:type="Property">
            <source localId="169" locator="67:57-67:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="168" locator="67:32-67:53" name="fhir:AssertionResponseTypes" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="175" locator="68:1-68:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="175">
               <a:s>define function ToString(value </a:s>
               <a:s r="172">
                  <a:s>AuditEventAction</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="174">
                  <a:s r="174">
                     <a:s r="173">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="174">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="174" locator="68:51-68:61" path="value" xsi:type="Property">
            <source localId="173" locator="68:51-68:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="172" locator="68:32-68:47" name="fhir:AuditEventAction" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="179" locator="69:1-69:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="179">
               <a:s>define function ToString(value </a:s>
               <a:s r="176">
                  <a:s>AuditEventAgentNetworkType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="178">
                  <a:s r="178">
                     <a:s r="177">
                        <a:s>value</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>
         </annotation>
         <expression localId="178" locator="69:61-69:71" path="value" xsi:type="Property">
            <source localId="177" locator="69:61-69:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="176" locator="69:32-69:57" name="fhir:AuditEventAgentNetworkType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="183" locator="70:1-70:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="183">
               <a:s>define function ToString(value </a:s>
               <a:s r="180">
                  <a:s>AuditEventOutcome</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="182">
                  <a:s r="182">
                     <a:s r="181">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="182">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="182" locator="70:52-70:62" path="value" xsi:type="Property">
            <source localId="181" locator="70:52-70:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="180" locator="70:32-70:48" name="fhir:AuditEventOutcome" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="187" locator="71:1-71:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="187">
               <a:s>define function ToString(value </a:s>
               <a:s r="184">
                  <a:s>BindingStrength</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="186">
                  <a:s r="186">
                     <a:s r="185">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="186">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="186" locator="71:50-71:60" path="value" xsi:type="Property">
            <source localId="185" locator="71:50-71:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="184" locator="71:32-71:46" name="fhir:BindingStrength" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="191" locator="72:1-72:79" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="191">
               <a:s>define function ToString(value </a:s>
               <a:s r="188">
                  <a:s>BiologicallyDerivedProductCategory</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="190">
                  <a:s r="190">
                     <a:s r="189">
                        <a:s>value</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>
         </annotation>
         <expression localId="190" locator="72:69-72:79" path="value" xsi:type="Property">
            <source localId="189" locator="72:69-72:73" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="188" locator="72:32-72:65" name="fhir:BiologicallyDerivedProductCategory" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="195" locator="73:1-73:77" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="195">
               <a:s>define function ToString(value </a:s>
               <a:s r="192">
                  <a:s>BiologicallyDerivedProductStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="194">
                  <a:s r="194">
                     <a:s r="193">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="194">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="194" locator="73:67-73:77" path="value" xsi:type="Property">
            <source localId="193" locator="73:67-73:71" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="192" locator="73:32-73:63" name="fhir:BiologicallyDerivedProductStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="199" locator="74:1-74:83" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="199">
               <a:s>define function ToString(value </a:s>
               <a:s r="196">
                  <a:s>BiologicallyDerivedProductStorageScale</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="198">
                  <a:s r="198">
                     <a:s r="197">
                        <a:s>value</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>
         </annotation>
         <expression localId="198" locator="74:73-74:83" path="value" xsi:type="Property">
            <source localId="197" locator="74:73-74:77" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="196" locator="74:32-74:69" name="fhir:BiologicallyDerivedProductStorageScale" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="203" locator="75:1-75:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="203">
               <a:s>define function ToString(value </a:s>
               <a:s r="200">
                  <a:s>BundleType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="202">
                  <a:s r="202">
                     <a:s r="201">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="202">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="202" locator="75:45-75:55" path="value" xsi:type="Property">
            <source localId="201" locator="75:45-75:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="200" locator="75:32-75:41" name="fhir:BundleType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="207" locator="76:1-76:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="207">
               <a:s>define function ToString(value </a:s>
               <a:s r="204">
                  <a:s>CapabilityStatementKind</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="206">
                  <a:s r="206">
                     <a:s r="205">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="206">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="206" locator="76:58-76:68" path="value" xsi:type="Property">
            <source localId="205" locator="76:58-76:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="204" locator="76:32-76:54" name="fhir:CapabilityStatementKind" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="211" locator="77:1-77:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="211">
               <a:s>define function ToString(value </a:s>
               <a:s r="208">
                  <a:s>CarePlanActivityKind</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="210">
                  <a:s r="210">
                     <a:s r="209">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="210">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="210" locator="77:55-77:65" path="value" xsi:type="Property">
            <source localId="209" locator="77:55-77:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="208" locator="77:32-77:51" name="fhir:CarePlanActivityKind" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="215" locator="78:1-78:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="215">
               <a:s>define function ToString(value </a:s>
               <a:s r="212">
                  <a:s>CarePlanActivityStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="214">
                  <a:s r="214">
                     <a:s r="213">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="214">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="214" locator="78:57-78:67" path="value" xsi:type="Property">
            <source localId="213" locator="78:57-78:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="212" locator="78:32-78:53" name="fhir:CarePlanActivityStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="219" locator="79:1-79:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="219">
               <a:s>define function ToString(value </a:s>
               <a:s r="216">
                  <a:s>CarePlanIntent</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="218">
                  <a:s r="218">
                     <a:s r="217">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="218">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="218" locator="79:49-79:59" path="value" xsi:type="Property">
            <source localId="217" locator="79:49-79:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="216" locator="79:32-79:45" name="fhir:CarePlanIntent" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="223" locator="80:1-80:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="223">
               <a:s>define function ToString(value </a:s>
               <a:s r="220">
                  <a:s>CarePlanStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="222">
                  <a:s r="222">
                     <a:s r="221">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="222">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="222" locator="80:49-80:59" path="value" xsi:type="Property">
            <source localId="221" locator="80:49-80:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="220" locator="80:32-80:45" name="fhir:CarePlanStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="227" locator="81:1-81:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="227">
               <a:s>define function ToString(value </a:s>
               <a:s r="224">
                  <a:s>CareTeamStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="226">
                  <a:s r="226">
                     <a:s r="225">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="226">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="226" locator="81:49-81:59" path="value" xsi:type="Property">
            <source localId="225" locator="81:49-81:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="224" locator="81:32-81:45" name="fhir:CareTeamStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="231" locator="82:1-82:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="231">
               <a:s>define function ToString(value </a:s>
               <a:s r="228">
                  <a:s>CatalogEntryRelationType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="230">
                  <a:s r="230">
                     <a:s r="229">
                        <a:s>value</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>
         </annotation>
         <expression localId="230" locator="82:59-82:69" path="value" xsi:type="Property">
            <source localId="229" locator="82:59-82:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="228" locator="82:32-82:55" name="fhir:CatalogEntryRelationType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="235" locator="83:1-83:83" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="235">
               <a:s>define function ToString(value </a:s>
               <a:s r="232">
                  <a:s>ChargeItemDefinitionPriceComponentType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="234">
                  <a:s r="234">
                     <a:s r="233">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="234">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="234" locator="83:73-83:83" path="value" xsi:type="Property">
            <source localId="233" locator="83:73-83:77" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="232" locator="83:32-83:69" name="fhir:ChargeItemDefinitionPriceComponentType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="239" locator="84:1-84:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="239">
               <a:s>define function ToString(value </a:s>
               <a:s r="236">
                  <a:s>ChargeItemStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="238">
                  <a:s r="238">
                     <a:s r="237">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="238">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="238" locator="84:51-84:61" path="value" xsi:type="Property">
            <source localId="237" locator="84:51-84:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="236" locator="84:32-84:47" name="fhir:ChargeItemStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="243" locator="85:1-85:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="243">
               <a:s>define function ToString(value </a:s>
               <a:s r="240">
                  <a:s>ClaimResponseStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="242">
                  <a:s r="242">
                     <a:s r="241">
                        <a:s>value</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>
         </annotation>
         <expression localId="242" locator="85:54-85:64" path="value" xsi:type="Property">
            <source localId="241" locator="85:54-85:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="240" locator="85:32-85:50" name="fhir:ClaimResponseStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="247" locator="86:1-86:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="247">
               <a:s>define function ToString(value </a:s>
               <a:s r="244">
                  <a:s>ClaimStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="246">
                  <a:s r="246">
                     <a:s r="245">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="246">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="246" locator="86:46-86:56" path="value" xsi:type="Property">
            <source localId="245" locator="86:46-86:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="244" locator="86:32-86:42" name="fhir:ClaimStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="251" locator="87:1-87:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="251">
               <a:s>define function ToString(value </a:s>
               <a:s r="248">
                  <a:s>ClinicalImpressionStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="250">
                  <a:s r="250">
                     <a:s r="249">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="250">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="250" locator="87:59-87:69" path="value" xsi:type="Property">
            <source localId="249" locator="87:59-87:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="248" locator="87:32-87:55" name="fhir:ClinicalImpressionStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="255" locator="88:1-88:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="255">
               <a:s>define function ToString(value </a:s>
               <a:s r="252">
                  <a:s>CodeSearchSupport</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="254">
                  <a:s r="254">
                     <a:s r="253">
                        <a:s>value</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>
         </annotation>
         <expression localId="254" locator="88:52-88:62" path="value" xsi:type="Property">
            <source localId="253" locator="88:52-88:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="252" locator="88:32-88:48" name="fhir:CodeSearchSupport" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="259" locator="89:1-89:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="259">
               <a:s>define function ToString(value </a:s>
               <a:s r="256">
                  <a:s>CodeSystemContentMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="258">
                  <a:s r="258">
                     <a:s r="257">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="258">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="258" locator="89:56-89:66" path="value" xsi:type="Property">
            <source localId="257" locator="89:56-89:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="256" locator="89:32-89:52" name="fhir:CodeSystemContentMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="263" locator="90:1-90:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="263">
               <a:s>define function ToString(value </a:s>
               <a:s r="260">
                  <a:s>CodeSystemHierarchyMeaning</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="262">
                  <a:s r="262">
                     <a:s r="261">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="262">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="262" locator="90:61-90:71" path="value" xsi:type="Property">
            <source localId="261" locator="90:61-90:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="260" locator="90:32-90:57" name="fhir:CodeSystemHierarchyMeaning" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="267" locator="91:1-91:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="267">
               <a:s>define function ToString(value </a:s>
               <a:s r="264">
                  <a:s>CommunicationPriority</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="266">
                  <a:s r="266">
                     <a:s r="265">
                        <a:s>value</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>
         </annotation>
         <expression localId="266" locator="91:56-91:66" path="value" xsi:type="Property">
            <source localId="265" locator="91:56-91:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="264" locator="91:32-91:52" name="fhir:CommunicationPriority" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="271" locator="92:1-92:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="271">
               <a:s>define function ToString(value </a:s>
               <a:s r="268">
                  <a:s>CommunicationRequestStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="270">
                  <a:s r="270">
                     <a:s r="269">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="270">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="270" locator="92:61-92:71" path="value" xsi:type="Property">
            <source localId="269" locator="92:61-92:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="268" locator="92:32-92:57" name="fhir:CommunicationRequestStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="275" locator="93:1-93:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="275">
               <a:s>define function ToString(value </a:s>
               <a:s r="272">
                  <a:s>CommunicationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="274">
                  <a:s r="274">
                     <a:s r="273">
                        <a:s>value</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>
         </annotation>
         <expression localId="274" locator="93:54-93:64" path="value" xsi:type="Property">
            <source localId="273" locator="93:54-93:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="272" locator="93:32-93:50" name="fhir:CommunicationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="279" locator="94:1-94:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="279">
               <a:s>define function ToString(value </a:s>
               <a:s r="276">
                  <a:s>CompartmentCode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="278">
                  <a:s r="278">
                     <a:s r="277">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="278">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="278" locator="94:50-94:60" path="value" xsi:type="Property">
            <source localId="277" locator="94:50-94:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="276" locator="94:32-94:46" name="fhir:CompartmentCode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="283" locator="95:1-95:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="283">
               <a:s>define function ToString(value </a:s>
               <a:s r="280">
                  <a:s>CompartmentType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="282">
                  <a:s r="282">
                     <a:s r="281">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="282">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="282" locator="95:50-95:60" path="value" xsi:type="Property">
            <source localId="281" locator="95:50-95:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="280" locator="95:32-95:46" name="fhir:CompartmentType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="287" locator="96:1-96:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="287">
               <a:s>define function ToString(value </a:s>
               <a:s r="284">
                  <a:s>CompositionAttestationMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="286">
                  <a:s r="286">
                     <a:s r="285">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="286">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="286" locator="96:61-96:71" path="value" xsi:type="Property">
            <source localId="285" locator="96:61-96:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="284" locator="96:32-96:57" name="fhir:CompositionAttestationMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="291" locator="97:1-97:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="291">
               <a:s>define function ToString(value </a:s>
               <a:s r="288">
                  <a:s>CompositionStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="290">
                  <a:s r="290">
                     <a:s r="289">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="290">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="290" locator="97:52-97:62" path="value" xsi:type="Property">
            <source localId="289" locator="97:52-97:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="288" locator="97:32-97:48" name="fhir:CompositionStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="295" locator="98:1-98:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="295">
               <a:s>define function ToString(value </a:s>
               <a:s r="292">
                  <a:s>ConceptMapEquivalence</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="294">
                  <a:s r="294">
                     <a:s r="293">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="294">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="294" locator="98:56-98:66" path="value" xsi:type="Property">
            <source localId="293" locator="98:56-98:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="292" locator="98:32-98:52" name="fhir:ConceptMapEquivalence" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="299" locator="99:1-99:72" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="299">
               <a:s>define function ToString(value </a:s>
               <a:s r="296">
                  <a:s>ConceptMapGroupUnmappedMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="298">
                  <a:s r="298">
                     <a:s r="297">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="298">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="298" locator="99:62-99:72" path="value" xsi:type="Property">
            <source localId="297" locator="99:62-99:66" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="296" locator="99:32-99:58" name="fhir:ConceptMapGroupUnmappedMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="303" locator="100:1-100:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="303">
               <a:s>define function ToString(value </a:s>
               <a:s r="300">
                  <a:s>ConditionalDeleteStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="302">
                  <a:s r="302">
                     <a:s r="301">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="302">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="302" locator="100:58-100:68" path="value" xsi:type="Property">
            <source localId="301" locator="100:58-100:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="300" locator="100:32-100:54" name="fhir:ConditionalDeleteStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="307" locator="101:1-101:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="307">
               <a:s>define function ToString(value </a:s>
               <a:s r="304">
                  <a:s>ConditionalReadStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="306">
                  <a:s r="306">
                     <a:s r="305">
                        <a:s>value</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>
         </annotation>
         <expression localId="306" locator="101:56-101:66" path="value" xsi:type="Property">
            <source localId="305" locator="101:56-101:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="304" locator="101:32-101:52" name="fhir:ConditionalReadStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="311" locator="102:1-102:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="311">
               <a:s>define function ToString(value </a:s>
               <a:s r="308">
                  <a:s>ConsentDataMeaning</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="310">
                  <a:s r="310">
                     <a:s r="309">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="310">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="310" locator="102:53-102:63" path="value" xsi:type="Property">
            <source localId="309" locator="102:53-102:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="308" locator="102:32-102:49" name="fhir:ConsentDataMeaning" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="315" locator="103:1-103:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="315">
               <a:s>define function ToString(value </a:s>
               <a:s r="312">
                  <a:s>ConsentProvisionType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="314">
                  <a:s r="314">
                     <a:s r="313">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="314">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="314" locator="103:55-103:65" path="value" xsi:type="Property">
            <source localId="313" locator="103:55-103:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="312" locator="103:32-103:51" name="fhir:ConsentProvisionType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="319" locator="104:1-104:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="319">
               <a:s>define function ToString(value </a:s>
               <a:s r="316">
                  <a:s>ConsentState</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="318">
                  <a:s r="318">
                     <a:s r="317">
                        <a:s>value</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>
         </annotation>
         <expression localId="318" locator="104:47-104:57" path="value" xsi:type="Property">
            <source localId="317" locator="104:47-104:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="316" locator="104:32-104:43" name="fhir:ConsentState" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="323" locator="105:1-105:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="323">
               <a:s>define function ToString(value </a:s>
               <a:s r="320">
                  <a:s>ConstraintSeverity</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="322">
                  <a:s r="322">
                     <a:s r="321">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="322">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="322" locator="105:53-105:63" path="value" xsi:type="Property">
            <source localId="321" locator="105:53-105:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="320" locator="105:32-105:49" name="fhir:ConstraintSeverity" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="327" locator="106:1-106:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="327">
               <a:s>define function ToString(value </a:s>
               <a:s r="324">
                  <a:s>ContactPointSystem</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="326">
                  <a:s r="326">
                     <a:s r="325">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="326">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="326" locator="106:53-106:63" path="value" xsi:type="Property">
            <source localId="325" locator="106:53-106:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="324" locator="106:32-106:49" name="fhir:ContactPointSystem" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="331" locator="107:1-107:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="331">
               <a:s>define function ToString(value </a:s>
               <a:s r="328">
                  <a:s>ContactPointUse</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="330">
                  <a:s r="330">
                     <a:s r="329">
                        <a:s>value</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>
         </annotation>
         <expression localId="330" locator="107:50-107:60" path="value" xsi:type="Property">
            <source localId="329" locator="107:50-107:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="328" locator="107:32-107:46" name="fhir:ContactPointUse" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="335" locator="108:1-108:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="335">
               <a:s>define function ToString(value </a:s>
               <a:s r="332">
                  <a:s>ContractPublicationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="334">
                  <a:s r="334">
                     <a:s r="333">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="334">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="334" locator="108:60-108:70" path="value" xsi:type="Property">
            <source localId="333" locator="108:60-108:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="332" locator="108:32-108:56" name="fhir:ContractPublicationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="339" locator="109:1-109:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="339">
               <a:s>define function ToString(value </a:s>
               <a:s r="336">
                  <a:s>ContractStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="338">
                  <a:s r="338">
                     <a:s r="337">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="338">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="338" locator="109:49-109:59" path="value" xsi:type="Property">
            <source localId="337" locator="109:49-109:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="336" locator="109:32-109:45" name="fhir:ContractStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="343" locator="110:1-110:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="343">
               <a:s>define function ToString(value </a:s>
               <a:s r="340">
                  <a:s>ContributorType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="342">
                  <a:s r="342">
                     <a:s r="341">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="342">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="342" locator="110:50-110:60" path="value" xsi:type="Property">
            <source localId="341" locator="110:50-110:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="340" locator="110:32-110:46" name="fhir:ContributorType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="347" locator="111:1-111:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="347">
               <a:s>define function ToString(value </a:s>
               <a:s r="344">
                  <a:s>CoverageStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="346">
                  <a:s r="346">
                     <a:s r="345">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="346">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="346" locator="111:49-111:59" path="value" xsi:type="Property">
            <source localId="345" locator="111:49-111:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="344" locator="111:32-111:45" name="fhir:CoverageStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="351" locator="112:1-112:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="351">
               <a:s>define function ToString(value </a:s>
               <a:s r="348">
                  <a:s>CurrencyCode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="350">
                  <a:s r="350">
                     <a:s r="349">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="350">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="350" locator="112:47-112:57" path="value" xsi:type="Property">
            <source localId="349" locator="112:47-112:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="348" locator="112:32-112:43" name="fhir:CurrencyCode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="355" locator="113:1-113:54" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="355">
               <a:s>define function ToString(value </a:s>
               <a:s r="352">
                  <a:s>DayOfWeek</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="354">
                  <a:s r="354">
                     <a:s r="353">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="354">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="354" locator="113:44-113:54" path="value" xsi:type="Property">
            <source localId="353" locator="113:44-113:48" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="352" locator="113:32-113:40" name="fhir:DayOfWeek" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="359" locator="114:1-114:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="359">
               <a:s>define function ToString(value </a:s>
               <a:s r="356">
                  <a:s>DaysOfWeek</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="358">
                  <a:s r="358">
                     <a:s r="357">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="358">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="358" locator="114:45-114:55" path="value" xsi:type="Property">
            <source localId="357" locator="114:45-114:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="356" locator="114:32-114:41" name="fhir:DaysOfWeek" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="363" locator="115:1-115:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="363">
               <a:s>define function ToString(value </a:s>
               <a:s r="360">
                  <a:s>DetectedIssueSeverity</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="362">
                  <a:s r="362">
                     <a:s r="361">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="362">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="362" locator="115:56-115:66" path="value" xsi:type="Property">
            <source localId="361" locator="115:56-115:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="360" locator="115:32-115:52" name="fhir:DetectedIssueSeverity" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="367" locator="116:1-116:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="367">
               <a:s>define function ToString(value </a:s>
               <a:s r="364">
                  <a:s>DetectedIssueStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="366">
                  <a:s r="366">
                     <a:s r="365">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="366">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="366" locator="116:54-116:64" path="value" xsi:type="Property">
            <source localId="365" locator="116:54-116:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="364" locator="116:32-116:50" name="fhir:DetectedIssueStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="371" locator="117:1-117:73" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="371">
               <a:s>define function ToString(value </a:s>
               <a:s r="368">
                  <a:s>DeviceMetricCalibrationState</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="370">
                  <a:s r="370">
                     <a:s r="369">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="370">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="370" locator="117:63-117:73" path="value" xsi:type="Property">
            <source localId="369" locator="117:63-117:67" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="368" locator="117:32-117:59" name="fhir:DeviceMetricCalibrationState" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="375" locator="118:1-118:72" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="375">
               <a:s>define function ToString(value </a:s>
               <a:s r="372">
                  <a:s>DeviceMetricCalibrationType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="374">
                  <a:s r="374">
                     <a:s r="373">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="374">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="374" locator="118:62-118:72" path="value" xsi:type="Property">
            <source localId="373" locator="118:62-118:66" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="372" locator="118:32-118:58" name="fhir:DeviceMetricCalibrationType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="379" locator="119:1-119:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="379">
               <a:s>define function ToString(value </a:s>
               <a:s r="376">
                  <a:s>DeviceMetricCategory</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="378">
                  <a:s r="378">
                     <a:s r="377">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="378">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="378" locator="119:55-119:65" path="value" xsi:type="Property">
            <source localId="377" locator="119:55-119:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="376" locator="119:32-119:51" name="fhir:DeviceMetricCategory" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="383" locator="120:1-120:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="383">
               <a:s>define function ToString(value </a:s>
               <a:s r="380">
                  <a:s>DeviceMetricColor</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="382">
                  <a:s r="382">
                     <a:s r="381">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="382">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="382" locator="120:52-120:62" path="value" xsi:type="Property">
            <source localId="381" locator="120:52-120:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="380" locator="120:32-120:48" name="fhir:DeviceMetricColor" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="387" locator="121:1-121:74" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="387">
               <a:s>define function ToString(value </a:s>
               <a:s r="384">
                  <a:s>DeviceMetricOperationalStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="386">
                  <a:s r="386">
                     <a:s r="385">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="386">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="386" locator="121:64-121:74" path="value" xsi:type="Property">
            <source localId="385" locator="121:64-121:68" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="384" locator="121:32-121:60" name="fhir:DeviceMetricOperationalStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="391" locator="122:1-122:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="391">
               <a:s>define function ToString(value </a:s>
               <a:s r="388">
                  <a:s>DeviceNameType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="390">
                  <a:s r="390">
                     <a:s r="389">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="390">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="390" locator="122:49-122:59" path="value" xsi:type="Property">
            <source localId="389" locator="122:49-122:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="388" locator="122:32-122:45" name="fhir:DeviceNameType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="395" locator="123:1-123:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="395">
               <a:s>define function ToString(value </a:s>
               <a:s r="392">
                  <a:s>DeviceRequestStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="394">
                  <a:s r="394">
                     <a:s r="393">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="394">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="394" locator="123:54-123:64" path="value" xsi:type="Property">
            <source localId="393" locator="123:54-123:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="392" locator="123:32-123:50" name="fhir:DeviceRequestStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="399" locator="124:1-124:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="399">
               <a:s>define function ToString(value </a:s>
               <a:s r="396">
                  <a:s>DeviceUseStatementStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="398">
                  <a:s r="398">
                     <a:s r="397">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="398">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="398" locator="124:59-124:69" path="value" xsi:type="Property">
            <source localId="397" locator="124:59-124:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="396" locator="124:32-124:55" name="fhir:DeviceUseStatementStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="403" locator="125:1-125:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="403">
               <a:s>define function ToString(value </a:s>
               <a:s r="400">
                  <a:s>DiagnosticReportStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="402">
                  <a:s r="402">
                     <a:s r="401">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="402">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="402" locator="125:57-125:67" path="value" xsi:type="Property">
            <source localId="401" locator="125:57-125:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="400" locator="125:32-125:53" name="fhir:DiagnosticReportStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="407" locator="126:1-126:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="407">
               <a:s>define function ToString(value </a:s>
               <a:s r="404">
                  <a:s>DiscriminatorType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="406">
                  <a:s r="406">
                     <a:s r="405">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="406">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="406" locator="126:52-126:62" path="value" xsi:type="Property">
            <source localId="405" locator="126:52-126:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="404" locator="126:32-126:48" name="fhir:DiscriminatorType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="411" locator="127:1-127:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="411">
               <a:s>define function ToString(value </a:s>
               <a:s r="408">
                  <a:s>DocumentConfidentiality</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="410">
                  <a:s r="410">
                     <a:s r="409">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="410">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="410" locator="127:58-127:68" path="value" xsi:type="Property">
            <source localId="409" locator="127:58-127:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="408" locator="127:32-127:54" name="fhir:DocumentConfidentiality" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="415" locator="128:1-128:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="415">
               <a:s>define function ToString(value </a:s>
               <a:s r="412">
                  <a:s>DocumentMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="414">
                  <a:s r="414">
                     <a:s r="413">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="414">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="414" locator="128:47-128:57" path="value" xsi:type="Property">
            <source localId="413" locator="128:47-128:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="412" locator="128:32-128:43" name="fhir:DocumentMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="419" locator="129:1-129:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="419">
               <a:s>define function ToString(value </a:s>
               <a:s r="416">
                  <a:s>DocumentReferenceStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="418">
                  <a:s r="418">
                     <a:s r="417">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="418">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="418" locator="129:58-129:68" path="value" xsi:type="Property">
            <source localId="417" locator="129:58-129:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="416" locator="129:32-129:54" name="fhir:DocumentReferenceStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="423" locator="130:1-130:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="423">
               <a:s>define function ToString(value </a:s>
               <a:s r="420">
                  <a:s>DocumentRelationshipType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="422">
                  <a:s r="422">
                     <a:s r="421">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="422">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="422" locator="130:59-130:69" path="value" xsi:type="Property">
            <source localId="421" locator="130:59-130:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="420" locator="130:32-130:55" name="fhir:DocumentRelationshipType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="427" locator="131:1-131:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="427">
               <a:s>define function ToString(value </a:s>
               <a:s r="424">
                  <a:s>EligibilityRequestPurpose</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="426">
                  <a:s r="426">
                     <a:s r="425">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="426">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="426" locator="131:60-131:70" path="value" xsi:type="Property">
            <source localId="425" locator="131:60-131:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="424" locator="131:32-131:56" name="fhir:EligibilityRequestPurpose" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="431" locator="132:1-132:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="431">
               <a:s>define function ToString(value </a:s>
               <a:s r="428">
                  <a:s>EligibilityRequestStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="430">
                  <a:s r="430">
                     <a:s r="429">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="430">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="430" locator="132:59-132:69" path="value" xsi:type="Property">
            <source localId="429" locator="132:59-132:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="428" locator="132:32-132:55" name="fhir:EligibilityRequestStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="435" locator="133:1-133:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="435">
               <a:s>define function ToString(value </a:s>
               <a:s r="432">
                  <a:s>EligibilityResponsePurpose</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="434">
                  <a:s r="434">
                     <a:s r="433">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="434">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="434" locator="133:61-133:71" path="value" xsi:type="Property">
            <source localId="433" locator="133:61-133:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="432" locator="133:32-133:57" name="fhir:EligibilityResponsePurpose" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="439" locator="134:1-134:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="439">
               <a:s>define function ToString(value </a:s>
               <a:s r="436">
                  <a:s>EligibilityResponseStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="438">
                  <a:s r="438">
                     <a:s r="437">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="438">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="438" locator="134:60-134:70" path="value" xsi:type="Property">
            <source localId="437" locator="134:60-134:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="436" locator="134:32-134:56" name="fhir:EligibilityResponseStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="443" locator="135:1-135:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="443">
               <a:s>define function ToString(value </a:s>
               <a:s r="440">
                  <a:s>EnableWhenBehavior</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="442">
                  <a:s r="442">
                     <a:s r="441">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="442">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="442" locator="135:53-135:63" path="value" xsi:type="Property">
            <source localId="441" locator="135:53-135:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="440" locator="135:32-135:49" name="fhir:EnableWhenBehavior" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="447" locator="136:1-136:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="447">
               <a:s>define function ToString(value </a:s>
               <a:s r="444">
                  <a:s>EncounterLocationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="446">
                  <a:s r="446">
                     <a:s r="445">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="446">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="446" locator="136:58-136:68" path="value" xsi:type="Property">
            <source localId="445" locator="136:58-136:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="444" locator="136:32-136:54" name="fhir:EncounterLocationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="451" locator="137:1-137:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="451">
               <a:s>define function ToString(value </a:s>
               <a:s r="448">
                  <a:s>EncounterStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="450">
                  <a:s r="450">
                     <a:s r="449">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="450">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="450" locator="137:50-137:60" path="value" xsi:type="Property">
            <source localId="449" locator="137:50-137:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="448" locator="137:32-137:46" name="fhir:EncounterStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="455" locator="138:1-138:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="455">
               <a:s>define function ToString(value </a:s>
               <a:s r="452">
                  <a:s>EndpointStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="454">
                  <a:s r="454">
                     <a:s r="453">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="454">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="454" locator="138:49-138:59" path="value" xsi:type="Property">
            <source localId="453" locator="138:49-138:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="452" locator="138:32-138:45" name="fhir:EndpointStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="459" locator="139:1-139:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="459">
               <a:s>define function ToString(value </a:s>
               <a:s r="456">
                  <a:s>EnrollmentRequestStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="458">
                  <a:s r="458">
                     <a:s r="457">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="458">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="458" locator="139:58-139:68" path="value" xsi:type="Property">
            <source localId="457" locator="139:58-139:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="456" locator="139:32-139:54" name="fhir:EnrollmentRequestStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="463" locator="140:1-140:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="463">
               <a:s>define function ToString(value </a:s>
               <a:s r="460">
                  <a:s>EnrollmentResponseStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="462">
                  <a:s r="462">
                     <a:s r="461">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="462">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="462" locator="140:59-140:69" path="value" xsi:type="Property">
            <source localId="461" locator="140:59-140:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="460" locator="140:32-140:55" name="fhir:EnrollmentResponseStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="467" locator="141:1-141:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="467">
               <a:s>define function ToString(value </a:s>
               <a:s r="464">
                  <a:s>EpisodeOfCareStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="466">
                  <a:s r="466">
                     <a:s r="465">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="466">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="466" locator="141:54-141:64" path="value" xsi:type="Property">
            <source localId="465" locator="141:54-141:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="464" locator="141:32-141:50" name="fhir:EpisodeOfCareStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="471" locator="142:1-142:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="471">
               <a:s>define function ToString(value </a:s>
               <a:s r="468">
                  <a:s>EventCapabilityMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="470">
                  <a:s r="470">
                     <a:s r="469">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="470">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="470" locator="142:54-142:64" path="value" xsi:type="Property">
            <source localId="469" locator="142:54-142:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="468" locator="142:32-142:50" name="fhir:EventCapabilityMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="475" locator="143:1-143:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="475">
               <a:s>define function ToString(value </a:s>
               <a:s r="472">
                  <a:s>EventTiming</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="474">
                  <a:s r="474">
                     <a:s r="473">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="474">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="474" locator="143:46-143:56" path="value" xsi:type="Property">
            <source localId="473" locator="143:46-143:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="472" locator="143:32-143:42" name="fhir:EventTiming" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="479" locator="144:1-144:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="479">
               <a:s>define function ToString(value </a:s>
               <a:s r="476">
                  <a:s>EvidenceVariableType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="478">
                  <a:s r="478">
                     <a:s r="477">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="478">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="478" locator="144:55-144:65" path="value" xsi:type="Property">
            <source localId="477" locator="144:55-144:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="476" locator="144:32-144:51" name="fhir:EvidenceVariableType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="483" locator="145:1-145:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="483">
               <a:s>define function ToString(value </a:s>
               <a:s r="480">
                  <a:s>ExampleScenarioActorType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="482">
                  <a:s r="482">
                     <a:s r="481">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="482">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="482" locator="145:59-145:69" path="value" xsi:type="Property">
            <source localId="481" locator="145:59-145:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="480" locator="145:32-145:55" name="fhir:ExampleScenarioActorType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="487" locator="146:1-146:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="487">
               <a:s>define function ToString(value </a:s>
               <a:s r="484">
                  <a:s>ExplanationOfBenefitStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="486">
                  <a:s r="486">
                     <a:s r="485">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="486">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="486" locator="146:61-146:71" path="value" xsi:type="Property">
            <source localId="485" locator="146:61-146:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="484" locator="146:32-146:57" name="fhir:ExplanationOfBenefitStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="491" locator="147:1-147:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="491">
               <a:s>define function ToString(value </a:s>
               <a:s r="488">
                  <a:s>ExposureState</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="490">
                  <a:s r="490">
                     <a:s r="489">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="490">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="490" locator="147:48-147:58" path="value" xsi:type="Property">
            <source localId="489" locator="147:48-147:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="488" locator="147:32-147:44" name="fhir:ExposureState" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="495" locator="148:1-148:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="495">
               <a:s>define function ToString(value </a:s>
               <a:s r="492">
                  <a:s>ExtensionContextType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="494">
                  <a:s r="494">
                     <a:s r="493">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="494">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="494" locator="148:55-148:65" path="value" xsi:type="Property">
            <source localId="493" locator="148:55-148:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="492" locator="148:32-148:51" name="fhir:ExtensionContextType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="499" locator="149:1-149:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="499">
               <a:s>define function ToString(value </a:s>
               <a:s r="496">
                  <a:s>FHIRAllTypes</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="498">
                  <a:s r="498">
                     <a:s r="497">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="498">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="498" locator="149:47-149:57" path="value" xsi:type="Property">
            <source localId="497" locator="149:47-149:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="496" locator="149:32-149:43" name="fhir:FHIRAllTypes" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="503" locator="150:1-150:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="503">
               <a:s>define function ToString(value </a:s>
               <a:s r="500">
                  <a:s>FHIRDefinedType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="502">
                  <a:s r="502">
                     <a:s r="501">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="502">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="502" locator="150:50-150:60" path="value" xsi:type="Property">
            <source localId="501" locator="150:50-150:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="500" locator="150:32-150:46" name="fhir:FHIRDefinedType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="507" locator="151:1-151:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="507">
               <a:s>define function ToString(value </a:s>
               <a:s r="504">
                  <a:s>FHIRDeviceStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="506">
                  <a:s r="506">
                     <a:s r="505">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="506">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="506" locator="151:51-151:61" path="value" xsi:type="Property">
            <source localId="505" locator="151:51-151:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="504" locator="151:32-151:47" name="fhir:FHIRDeviceStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="511" locator="152:1-152:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="511">
               <a:s>define function ToString(value </a:s>
               <a:s r="508">
                  <a:s>FHIRResourceType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="510">
                  <a:s r="510">
                     <a:s r="509">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="510">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="510" locator="152:51-152:61" path="value" xsi:type="Property">
            <source localId="509" locator="152:51-152:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="508" locator="152:32-152:47" name="fhir:FHIRResourceType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="515" locator="153:1-153:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="515">
               <a:s>define function ToString(value </a:s>
               <a:s r="512">
                  <a:s>FHIRSubstanceStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="514">
                  <a:s r="514">
                     <a:s r="513">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="514">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="514" locator="153:54-153:64" path="value" xsi:type="Property">
            <source localId="513" locator="153:54-153:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="512" locator="153:32-153:50" name="fhir:FHIRSubstanceStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="519" locator="154:1-154:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="519">
               <a:s>define function ToString(value </a:s>
               <a:s r="516">
                  <a:s>FHIRVersion</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="518">
                  <a:s r="518">
                     <a:s r="517">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="518">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="518" locator="154:46-154:56" path="value" xsi:type="Property">
            <source localId="517" locator="154:46-154:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="516" locator="154:32-154:42" name="fhir:FHIRVersion" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="523" locator="155:1-155:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="523">
               <a:s>define function ToString(value </a:s>
               <a:s r="520">
                  <a:s>FamilyHistoryStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="522">
                  <a:s r="522">
                     <a:s r="521">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="522">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="522" locator="155:54-155:64" path="value" xsi:type="Property">
            <source localId="521" locator="155:54-155:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="520" locator="155:32-155:50" name="fhir:FamilyHistoryStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="527" locator="156:1-156:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="527">
               <a:s>define function ToString(value </a:s>
               <a:s r="524">
                  <a:s>FilterOperator</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="526">
                  <a:s r="526">
                     <a:s r="525">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="526">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="526" locator="156:49-156:59" path="value" xsi:type="Property">
            <source localId="525" locator="156:49-156:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="524" locator="156:32-156:45" name="fhir:FilterOperator" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="531" locator="157:1-157:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="531">
               <a:s>define function ToString(value </a:s>
               <a:s r="528">
                  <a:s>FlagStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="530">
                  <a:s r="530">
                     <a:s r="529">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="530">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="530" locator="157:45-157:55" path="value" xsi:type="Property">
            <source localId="529" locator="157:45-157:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="528" locator="157:32-157:41" name="fhir:FlagStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="535" locator="158:1-158:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="535">
               <a:s>define function ToString(value </a:s>
               <a:s r="532">
                  <a:s>GoalLifecycleStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="534">
                  <a:s r="534">
                     <a:s r="533">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="534">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="534" locator="158:54-158:64" path="value" xsi:type="Property">
            <source localId="533" locator="158:54-158:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="532" locator="158:32-158:50" name="fhir:GoalLifecycleStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="539" locator="159:1-159:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="539">
               <a:s>define function ToString(value </a:s>
               <a:s r="536">
                  <a:s>GraphCompartmentRule</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="538">
                  <a:s r="538">
                     <a:s r="537">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="538">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="538" locator="159:55-159:65" path="value" xsi:type="Property">
            <source localId="537" locator="159:55-159:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="536" locator="159:32-159:51" name="fhir:GraphCompartmentRule" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="543" locator="160:1-160:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="543">
               <a:s>define function ToString(value </a:s>
               <a:s r="540">
                  <a:s>GraphCompartmentUse</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="542">
                  <a:s r="542">
                     <a:s r="541">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="542">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="542" locator="160:54-160:64" path="value" xsi:type="Property">
            <source localId="541" locator="160:54-160:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="540" locator="160:32-160:50" name="fhir:GraphCompartmentUse" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="547" locator="161:1-161:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="547">
               <a:s>define function ToString(value </a:s>
               <a:s r="544">
                  <a:s>GroupMeasure</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="546">
                  <a:s r="546">
                     <a:s r="545">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="546">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="546" locator="161:47-161:57" path="value" xsi:type="Property">
            <source localId="545" locator="161:47-161:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="544" locator="161:32-161:43" name="fhir:GroupMeasure" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="551" locator="162:1-162:54" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="551">
               <a:s>define function ToString(value </a:s>
               <a:s r="548">
                  <a:s>GroupType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="550">
                  <a:s r="550">
                     <a:s r="549">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="550">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="550" locator="162:44-162:54" path="value" xsi:type="Property">
            <source localId="549" locator="162:44-162:48" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="548" locator="162:32-162:40" name="fhir:GroupType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="555" locator="163:1-163:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="555">
               <a:s>define function ToString(value </a:s>
               <a:s r="552">
                  <a:s>GuidanceResponseStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="554">
                  <a:s r="554">
                     <a:s r="553">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="554">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="554" locator="163:57-163:67" path="value" xsi:type="Property">
            <source localId="553" locator="163:57-163:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="552" locator="163:32-163:53" name="fhir:GuidanceResponseStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="559" locator="164:1-164:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="559">
               <a:s>define function ToString(value </a:s>
               <a:s r="556">
                  <a:s>GuidePageGeneration</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="558">
                  <a:s r="558">
                     <a:s r="557">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="558">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="558" locator="164:54-164:64" path="value" xsi:type="Property">
            <source localId="557" locator="164:54-164:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="556" locator="164:32-164:50" name="fhir:GuidePageGeneration" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="563" locator="165:1-165:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="563">
               <a:s>define function ToString(value </a:s>
               <a:s r="560">
                  <a:s>GuideParameterCode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="562">
                  <a:s r="562">
                     <a:s r="561">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="562">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="562" locator="165:53-165:63" path="value" xsi:type="Property">
            <source localId="561" locator="165:53-165:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="560" locator="165:32-165:49" name="fhir:GuideParameterCode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="567" locator="166:1-166:53" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="567">
               <a:s>define function ToString(value </a:s>
               <a:s r="564">
                  <a:s>HTTPVerb</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="566">
                  <a:s r="566">
                     <a:s r="565">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="566">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="566" locator="166:43-166:53" path="value" xsi:type="Property">
            <source localId="565" locator="166:43-166:47" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="564" locator="166:32-166:39" name="fhir:HTTPVerb" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="571" locator="167:1-167:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="571">
               <a:s>define function ToString(value </a:s>
               <a:s r="568">
                  <a:s>IdentifierUse</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="570">
                  <a:s r="570">
                     <a:s r="569">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="570">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="570" locator="167:48-167:58" path="value" xsi:type="Property">
            <source localId="569" locator="167:48-167:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="568" locator="167:32-167:44" name="fhir:IdentifierUse" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="575" locator="168:1-168:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="575">
               <a:s>define function ToString(value </a:s>
               <a:s r="572">
                  <a:s>IdentityAssuranceLevel</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="574">
                  <a:s r="574">
                     <a:s r="573">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="574">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="574" locator="168:57-168:67" path="value" xsi:type="Property">
            <source localId="573" locator="168:57-168:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="572" locator="168:32-168:53" name="fhir:IdentityAssuranceLevel" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="579" locator="169:1-169:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="579">
               <a:s>define function ToString(value </a:s>
               <a:s r="576">
                  <a:s>ImagingStudyStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="578">
                  <a:s r="578">
                     <a:s r="577">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="578">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="578" locator="169:53-169:63" path="value" xsi:type="Property">
            <source localId="577" locator="169:53-169:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="576" locator="169:32-169:49" name="fhir:ImagingStudyStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="583" locator="170:1-170:73" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="583">
               <a:s>define function ToString(value </a:s>
               <a:s r="580">
                  <a:s>ImmunizationEvaluationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="582">
                  <a:s r="582">
                     <a:s r="581">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="582">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="582" locator="170:63-170:73" path="value" xsi:type="Property">
            <source localId="581" locator="170:63-170:67" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="580" locator="170:32-170:59" name="fhir:ImmunizationEvaluationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="587" locator="171:1-171:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="587">
               <a:s>define function ToString(value </a:s>
               <a:s r="584">
                  <a:s>ImmunizationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="586">
                  <a:s r="586">
                     <a:s r="585">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="586">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="586" locator="171:53-171:63" path="value" xsi:type="Property">
            <source localId="585" locator="171:53-171:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="584" locator="171:32-171:49" name="fhir:ImmunizationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="591" locator="172:1-172:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="591">
               <a:s>define function ToString(value </a:s>
               <a:s r="588">
                  <a:s>InvoicePriceComponentType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="590">
                  <a:s r="590">
                     <a:s r="589">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="590">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="590" locator="172:60-172:70" path="value" xsi:type="Property">
            <source localId="589" locator="172:60-172:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="588" locator="172:32-172:56" name="fhir:InvoicePriceComponentType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="595" locator="173:1-173:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="595">
               <a:s>define function ToString(value </a:s>
               <a:s r="592">
                  <a:s>InvoiceStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="594">
                  <a:s r="594">
                     <a:s r="593">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="594">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="594" locator="173:48-173:58" path="value" xsi:type="Property">
            <source localId="593" locator="173:48-173:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="592" locator="173:32-173:44" name="fhir:InvoiceStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="599" locator="174:1-174:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="599">
               <a:s>define function ToString(value </a:s>
               <a:s r="596">
                  <a:s>IssueSeverity</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="598">
                  <a:s r="598">
                     <a:s r="597">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="598">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="598" locator="174:48-174:58" path="value" xsi:type="Property">
            <source localId="597" locator="174:48-174:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="596" locator="174:32-174:44" name="fhir:IssueSeverity" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="603" locator="175:1-175:54" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="603">
               <a:s>define function ToString(value </a:s>
               <a:s r="600">
                  <a:s>IssueType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="602">
                  <a:s r="602">
                     <a:s r="601">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="602">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="602" locator="175:44-175:54" path="value" xsi:type="Property">
            <source localId="601" locator="175:44-175:48" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="600" locator="175:32-175:40" name="fhir:IssueType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="607" locator="176:1-176:53" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="607">
               <a:s>define function ToString(value </a:s>
               <a:s r="604">
                  <a:s>LinkType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="606">
                  <a:s r="606">
                     <a:s r="605">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="606">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="606" locator="176:43-176:53" path="value" xsi:type="Property">
            <source localId="605" locator="176:43-176:47" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="604" locator="176:32-176:39" name="fhir:LinkType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="611" locator="177:1-177:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="611">
               <a:s>define function ToString(value </a:s>
               <a:s r="608">
                  <a:s>LinkageType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="610">
                  <a:s r="610">
                     <a:s r="609">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="610">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="610" locator="177:46-177:56" path="value" xsi:type="Property">
            <source localId="609" locator="177:46-177:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="608" locator="177:32-177:42" name="fhir:LinkageType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="615" locator="178:1-178:53" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="615">
               <a:s>define function ToString(value </a:s>
               <a:s r="612">
                  <a:s>ListMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="614">
                  <a:s r="614">
                     <a:s r="613">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="614">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="614" locator="178:43-178:53" path="value" xsi:type="Property">
            <source localId="613" locator="178:43-178:47" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="612" locator="178:32-178:39" name="fhir:ListMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="619" locator="179:1-179:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="619">
               <a:s>define function ToString(value </a:s>
               <a:s r="616">
                  <a:s>ListStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="618">
                  <a:s r="618">
                     <a:s r="617">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="618">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="618" locator="179:45-179:55" path="value" xsi:type="Property">
            <source localId="617" locator="179:45-179:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="616" locator="179:32-179:41" name="fhir:ListStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="623" locator="180:1-180:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="623">
               <a:s>define function ToString(value </a:s>
               <a:s r="620">
                  <a:s>LocationMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="622">
                  <a:s r="622">
                     <a:s r="621">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="622">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="622" locator="180:47-180:57" path="value" xsi:type="Property">
            <source localId="621" locator="180:47-180:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="620" locator="180:32-180:43" name="fhir:LocationMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="627" locator="181:1-181:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="627">
               <a:s>define function ToString(value </a:s>
               <a:s r="624">
                  <a:s>LocationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="626">
                  <a:s r="626">
                     <a:s r="625">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="626">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="626" locator="181:49-181:59" path="value" xsi:type="Property">
            <source localId="625" locator="181:49-181:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="624" locator="181:32-181:45" name="fhir:LocationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="631" locator="182:1-182:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="631">
               <a:s>define function ToString(value </a:s>
               <a:s r="628">
                  <a:s>MeasureReportStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="630">
                  <a:s r="630">
                     <a:s r="629">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="630">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="630" locator="182:54-182:64" path="value" xsi:type="Property">
            <source localId="629" locator="182:54-182:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="628" locator="182:32-182:50" name="fhir:MeasureReportStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="635" locator="183:1-183:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="635">
               <a:s>define function ToString(value </a:s>
               <a:s r="632">
                  <a:s>MeasureReportType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="634">
                  <a:s r="634">
                     <a:s r="633">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="634">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="634" locator="183:52-183:62" path="value" xsi:type="Property">
            <source localId="633" locator="183:52-183:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="632" locator="183:32-183:48" name="fhir:MeasureReportType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="639" locator="184:1-184:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="639">
               <a:s>define function ToString(value </a:s>
               <a:s r="636">
                  <a:s>MediaStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="638">
                  <a:s r="638">
                     <a:s r="637">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="638">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="638" locator="184:46-184:56" path="value" xsi:type="Property">
            <source localId="637" locator="184:46-184:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="636" locator="184:32-184:42" name="fhir:MediaStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="643" locator="185:1-185:75" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="643">
               <a:s>define function ToString(value </a:s>
               <a:s r="640">
                  <a:s>MedicationAdministrationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="642">
                  <a:s r="642">
                     <a:s r="641">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="642">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="642" locator="185:65-185:75" path="value" xsi:type="Property">
            <source localId="641" locator="185:65-185:69" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="640" locator="185:32-185:61" name="fhir:MedicationAdministrationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="647" locator="186:1-186:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="647">
               <a:s>define function ToString(value </a:s>
               <a:s r="644">
                  <a:s>MedicationDispenseStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="646">
                  <a:s r="646">
                     <a:s r="645">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="646">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="646" locator="186:59-186:69" path="value" xsi:type="Property">
            <source localId="645" locator="186:59-186:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="644" locator="186:32-186:55" name="fhir:MedicationDispenseStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="651" locator="187:1-187:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="651">
               <a:s>define function ToString(value </a:s>
               <a:s r="648">
                  <a:s>MedicationKnowledgeStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="650">
                  <a:s r="650">
                     <a:s r="649">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="650">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="650" locator="187:60-187:70" path="value" xsi:type="Property">
            <source localId="649" locator="187:60-187:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="648" locator="187:32-187:56" name="fhir:MedicationKnowledgeStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="655" locator="188:1-188:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="655">
               <a:s>define function ToString(value </a:s>
               <a:s r="652">
                  <a:s>MedicationRequestIntent</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="654">
                  <a:s r="654">
                     <a:s r="653">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="654">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="654" locator="188:58-188:68" path="value" xsi:type="Property">
            <source localId="653" locator="188:58-188:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="652" locator="188:32-188:54" name="fhir:MedicationRequestIntent" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="659" locator="189:1-189:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="659">
               <a:s>define function ToString(value </a:s>
               <a:s r="656">
                  <a:s>MedicationRequestPriority</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="658">
                  <a:s r="658">
                     <a:s r="657">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="658">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="658" locator="189:60-189:70" path="value" xsi:type="Property">
            <source localId="657" locator="189:60-189:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="656" locator="189:32-189:56" name="fhir:MedicationRequestPriority" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="663" locator="190:1-190:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="663">
               <a:s>define function ToString(value </a:s>
               <a:s r="660">
                  <a:s>MedicationRequestStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="662">
                  <a:s r="662">
                     <a:s r="661">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="662">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="662" locator="190:58-190:68" path="value" xsi:type="Property">
            <source localId="661" locator="190:58-190:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="660" locator="190:32-190:54" name="fhir:MedicationRequestStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="667" locator="191:1-191:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="667">
               <a:s>define function ToString(value </a:s>
               <a:s r="664">
                  <a:s>MedicationStatementStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="666">
                  <a:s r="666">
                     <a:s r="665">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="666">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="666" locator="191:60-191:70" path="value" xsi:type="Property">
            <source localId="665" locator="191:60-191:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="664" locator="191:32-191:56" name="fhir:MedicationStatementStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="671" locator="192:1-192:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="671">
               <a:s>define function ToString(value </a:s>
               <a:s r="668">
                  <a:s>MedicationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="670">
                  <a:s r="670">
                     <a:s r="669">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="670">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="670" locator="192:51-192:61" path="value" xsi:type="Property">
            <source localId="669" locator="192:51-192:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="668" locator="192:32-192:47" name="fhir:MedicationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="675" locator="193:1-193:72" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="675">
               <a:s>define function ToString(value </a:s>
               <a:s r="672">
                  <a:s>MessageSignificanceCategory</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="674">
                  <a:s r="674">
                     <a:s r="673">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="674">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="674" locator="193:62-193:72" path="value" xsi:type="Property">
            <source localId="673" locator="193:62-193:66" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="672" locator="193:32-193:58" name="fhir:MessageSignificanceCategory" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="679" locator="194:1-194:75" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="679">
               <a:s>define function ToString(value </a:s>
               <a:s r="676">
                  <a:s>Messageheader_Response_Request</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="678">
                  <a:s r="678">
                     <a:s r="677">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="678">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="678" locator="194:65-194:75" path="value" xsi:type="Property">
            <source localId="677" locator="194:65-194:69" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="676" locator="194:32-194:61" name="fhir:Messageheader_Response_Request" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="683" locator="195:1-195:53" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="683">
               <a:s>define function ToString(value </a:s>
               <a:s r="680">
                  <a:s>MimeType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="682">
                  <a:s r="682">
                     <a:s r="681">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="682">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="682" locator="195:43-195:53" path="value" xsi:type="Property">
            <source localId="681" locator="195:43-195:47" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="680" locator="195:32-195:39" name="fhir:MimeType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="687" locator="196:1-196:52" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="687">
               <a:s>define function ToString(value </a:s>
               <a:s r="684">
                  <a:s>NameUse</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="686">
                  <a:s r="686">
                     <a:s r="685">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="686">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="686" locator="196:42-196:52" path="value" xsi:type="Property">
            <source localId="685" locator="196:42-196:46" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="684" locator="196:32-196:38" name="fhir:NameUse" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="691" locator="197:1-197:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="691">
               <a:s>define function ToString(value </a:s>
               <a:s r="688">
                  <a:s>NamingSystemIdentifierType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="690">
                  <a:s r="690">
                     <a:s r="689">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="690">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="690" locator="197:61-197:71" path="value" xsi:type="Property">
            <source localId="689" locator="197:61-197:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="688" locator="197:32-197:57" name="fhir:NamingSystemIdentifierType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="695" locator="198:1-198:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="695">
               <a:s>define function ToString(value </a:s>
               <a:s r="692">
                  <a:s>NamingSystemType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="694">
                  <a:s r="694">
                     <a:s r="693">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="694">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="694" locator="198:51-198:61" path="value" xsi:type="Property">
            <source localId="693" locator="198:51-198:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="692" locator="198:32-198:47" name="fhir:NamingSystemType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="699" locator="199:1-199:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="699">
               <a:s>define function ToString(value </a:s>
               <a:s r="696">
                  <a:s>NarrativeStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="698">
                  <a:s r="698">
                     <a:s r="697">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="698">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="698" locator="199:50-199:60" path="value" xsi:type="Property">
            <source localId="697" locator="199:50-199:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="696" locator="199:32-199:46" name="fhir:NarrativeStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="703" locator="200:1-200:53" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="703">
               <a:s>define function ToString(value </a:s>
               <a:s r="700">
                  <a:s>NoteType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="702">
                  <a:s r="702">
                     <a:s r="701">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="702">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="702" locator="200:43-200:53" path="value" xsi:type="Property">
            <source localId="701" locator="200:43-200:47" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="700" locator="200:32-200:39" name="fhir:NoteType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="707" locator="201:1-201:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="707">
               <a:s>define function ToString(value </a:s>
               <a:s r="704">
                  <a:s>NutritiionOrderIntent</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="706">
                  <a:s r="706">
                     <a:s r="705">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="706">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="706" locator="201:56-201:66" path="value" xsi:type="Property">
            <source localId="705" locator="201:56-201:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="704" locator="201:32-201:52" name="fhir:NutritiionOrderIntent" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="711" locator="202:1-202:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="711">
               <a:s>define function ToString(value </a:s>
               <a:s r="708">
                  <a:s>NutritionOrderStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="710">
                  <a:s r="710">
                     <a:s r="709">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="710">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="710" locator="202:55-202:65" path="value" xsi:type="Property">
            <source localId="709" locator="202:55-202:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="708" locator="202:32-202:51" name="fhir:NutritionOrderStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="715" locator="203:1-203:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="715">
               <a:s>define function ToString(value </a:s>
               <a:s r="712">
                  <a:s>ObservationDataType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="714">
                  <a:s r="714">
                     <a:s r="713">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="714">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="714" locator="203:54-203:64" path="value" xsi:type="Property">
            <source localId="713" locator="203:54-203:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="712" locator="203:32-203:50" name="fhir:ObservationDataType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="719" locator="204:1-204:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="719">
               <a:s>define function ToString(value </a:s>
               <a:s r="716">
                  <a:s>ObservationRangeCategory</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="718">
                  <a:s r="718">
                     <a:s r="717">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="718">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="718" locator="204:59-204:69" path="value" xsi:type="Property">
            <source localId="717" locator="204:59-204:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="716" locator="204:32-204:55" name="fhir:ObservationRangeCategory" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="723" locator="205:1-205:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="723">
               <a:s>define function ToString(value </a:s>
               <a:s r="720">
                  <a:s>ObservationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="722">
                  <a:s r="722">
                     <a:s r="721">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="722">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="722" locator="205:52-205:62" path="value" xsi:type="Property">
            <source localId="721" locator="205:52-205:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="720" locator="205:32-205:48" name="fhir:ObservationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="727" locator="206:1-206:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="727">
               <a:s>define function ToString(value </a:s>
               <a:s r="724">
                  <a:s>OperationKind</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="726">
                  <a:s r="726">
                     <a:s r="725">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="726">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="726" locator="206:48-206:58" path="value" xsi:type="Property">
            <source localId="725" locator="206:48-206:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="724" locator="206:32-206:44" name="fhir:OperationKind" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="731" locator="207:1-207:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="731">
               <a:s>define function ToString(value </a:s>
               <a:s r="728">
                  <a:s>OperationParameterUse</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="730">
                  <a:s r="730">
                     <a:s r="729">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="730">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="730" locator="207:56-207:66" path="value" xsi:type="Property">
            <source localId="729" locator="207:56-207:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="728" locator="207:32-207:52" name="fhir:OperationParameterUse" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="735" locator="208:1-208:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="735">
               <a:s>define function ToString(value </a:s>
               <a:s r="732">
                  <a:s>OrientationType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="734">
                  <a:s r="734">
                     <a:s r="733">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="734">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="734" locator="208:50-208:60" path="value" xsi:type="Property">
            <source localId="733" locator="208:50-208:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="732" locator="208:32-208:46" name="fhir:OrientationType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="739" locator="209:1-209:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="739">
               <a:s>define function ToString(value </a:s>
               <a:s r="736">
                  <a:s>ParameterUse</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="738">
                  <a:s r="738">
                     <a:s r="737">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="738">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="738" locator="209:47-209:57" path="value" xsi:type="Property">
            <source localId="737" locator="209:47-209:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="736" locator="209:32-209:43" name="fhir:ParameterUse" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="743" locator="210:1-210:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="743">
               <a:s>define function ToString(value </a:s>
               <a:s r="740">
                  <a:s>ParticipantRequired</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="742">
                  <a:s r="742">
                     <a:s r="741">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="742">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="742" locator="210:54-210:64" path="value" xsi:type="Property">
            <source localId="741" locator="210:54-210:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="740" locator="210:32-210:50" name="fhir:ParticipantRequired" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="747" locator="211:1-211:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="747">
               <a:s>define function ToString(value </a:s>
               <a:s r="744">
                  <a:s>ParticipantStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="746">
                  <a:s r="746">
                     <a:s r="745">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="746">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="746" locator="211:52-211:62" path="value" xsi:type="Property">
            <source localId="745" locator="211:52-211:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="744" locator="211:32-211:48" name="fhir:ParticipantStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="751" locator="212:1-212:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="751">
               <a:s>define function ToString(value </a:s>
               <a:s r="748">
                  <a:s>ParticipationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="750">
                  <a:s r="750">
                     <a:s r="749">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="750">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="750" locator="212:54-212:64" path="value" xsi:type="Property">
            <source localId="749" locator="212:54-212:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="748" locator="212:32-212:50" name="fhir:ParticipationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="755" locator="213:1-213:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="755">
               <a:s>define function ToString(value </a:s>
               <a:s r="752">
                  <a:s>PaymentNoticeStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="754">
                  <a:s r="754">
                     <a:s r="753">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="754">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="754" locator="213:54-213:64" path="value" xsi:type="Property">
            <source localId="753" locator="213:54-213:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="752" locator="213:32-213:50" name="fhir:PaymentNoticeStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="759" locator="214:1-214:72" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="759">
               <a:s>define function ToString(value </a:s>
               <a:s r="756">
                  <a:s>PaymentReconciliationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="758">
                  <a:s r="758">
                     <a:s r="757">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="758">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="758" locator="214:62-214:72" path="value" xsi:type="Property">
            <source localId="757" locator="214:62-214:66" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="756" locator="214:32-214:58" name="fhir:PaymentReconciliationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="763" locator="215:1-215:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="763">
               <a:s>define function ToString(value </a:s>
               <a:s r="760">
                  <a:s>ProcedureStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="762">
                  <a:s r="762">
                     <a:s r="761">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="762">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="762" locator="215:50-215:60" path="value" xsi:type="Property">
            <source localId="761" locator="215:50-215:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="760" locator="215:32-215:46" name="fhir:ProcedureStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="767" locator="216:1-216:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="767">
               <a:s>define function ToString(value </a:s>
               <a:s r="764">
                  <a:s>PropertyRepresentation</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="766">
                  <a:s r="766">
                     <a:s r="765">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="766">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="766" locator="216:57-216:67" path="value" xsi:type="Property">
            <source localId="765" locator="216:57-216:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="764" locator="216:32-216:53" name="fhir:PropertyRepresentation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="771" locator="217:1-217:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="771">
               <a:s>define function ToString(value </a:s>
               <a:s r="768">
                  <a:s>PropertyType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="770">
                  <a:s r="770">
                     <a:s r="769">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="770">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="770" locator="217:47-217:57" path="value" xsi:type="Property">
            <source localId="769" locator="217:47-217:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="768" locator="217:32-217:43" name="fhir:PropertyType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="775" locator="218:1-218:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="775">
               <a:s>define function ToString(value </a:s>
               <a:s r="772">
                  <a:s>ProvenanceEntityRole</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="774">
                  <a:s r="774">
                     <a:s r="773">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="774">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="774" locator="218:55-218:65" path="value" xsi:type="Property">
            <source localId="773" locator="218:55-218:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="772" locator="218:32-218:51" name="fhir:ProvenanceEntityRole" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="779" locator="219:1-219:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="779">
               <a:s>define function ToString(value </a:s>
               <a:s r="776">
                  <a:s>PublicationStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="778">
                  <a:s r="778">
                     <a:s r="777">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="778">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="778" locator="219:52-219:62" path="value" xsi:type="Property">
            <source localId="777" locator="219:52-219:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="776" locator="219:32-219:48" name="fhir:PublicationStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="783" locator="220:1-220:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="783">
               <a:s>define function ToString(value </a:s>
               <a:s r="780">
                  <a:s>QualityType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="782">
                  <a:s r="782">
                     <a:s r="781">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="782">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="782" locator="220:46-220:56" path="value" xsi:type="Property">
            <source localId="781" locator="220:46-220:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="780" locator="220:32-220:42" name="fhir:QualityType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="787" locator="221:1-221:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="787">
               <a:s>define function ToString(value </a:s>
               <a:s r="784">
                  <a:s>QuantityComparator</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="786">
                  <a:s r="786">
                     <a:s r="785">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="786">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="786" locator="221:53-221:63" path="value" xsi:type="Property">
            <source localId="785" locator="221:53-221:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="784" locator="221:32-221:49" name="fhir:QuantityComparator" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="791" locator="222:1-222:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="791">
               <a:s>define function ToString(value </a:s>
               <a:s r="788">
                  <a:s>QuestionnaireItemOperator</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="790">
                  <a:s r="790">
                     <a:s r="789">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="790">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="790" locator="222:60-222:70" path="value" xsi:type="Property">
            <source localId="789" locator="222:60-222:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="788" locator="222:32-222:56" name="fhir:QuestionnaireItemOperator" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="795" locator="223:1-223:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="795">
               <a:s>define function ToString(value </a:s>
               <a:s r="792">
                  <a:s>QuestionnaireItemType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="794">
                  <a:s r="794">
                     <a:s r="793">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="794">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="794" locator="223:56-223:66" path="value" xsi:type="Property">
            <source localId="793" locator="223:56-223:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="792" locator="223:32-223:52" name="fhir:QuestionnaireItemType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="799" locator="224:1-224:72" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="799">
               <a:s>define function ToString(value </a:s>
               <a:s r="796">
                  <a:s>QuestionnaireResponseStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="798">
                  <a:s r="798">
                     <a:s r="797">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="798">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="798" locator="224:62-224:72" path="value" xsi:type="Property">
            <source localId="797" locator="224:62-224:66" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="796" locator="224:32-224:58" name="fhir:QuestionnaireResponseStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="803" locator="225:1-225:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="803">
               <a:s>define function ToString(value </a:s>
               <a:s r="800">
                  <a:s>ReferenceHandlingPolicy</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="802">
                  <a:s r="802">
                     <a:s r="801">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="802">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="802" locator="225:58-225:68" path="value" xsi:type="Property">
            <source localId="801" locator="225:58-225:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="800" locator="225:32-225:54" name="fhir:ReferenceHandlingPolicy" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="807" locator="226:1-226:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="807">
               <a:s>define function ToString(value </a:s>
               <a:s r="804">
                  <a:s>ReferenceVersionRules</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="806">
                  <a:s r="806">
                     <a:s r="805">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="806">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="806" locator="226:56-226:66" path="value" xsi:type="Property">
            <source localId="805" locator="226:56-226:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="804" locator="226:32-226:52" name="fhir:ReferenceVersionRules" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="811" locator="227:1-227:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="811">
               <a:s>define function ToString(value </a:s>
               <a:s r="808">
                  <a:s>ReferredDocumentStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="810">
                  <a:s r="810">
                     <a:s r="809">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="810">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="810" locator="227:57-227:67" path="value" xsi:type="Property">
            <source localId="809" locator="227:57-227:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="808" locator="227:32-227:53" name="fhir:ReferredDocumentStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="815" locator="228:1-228:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="815">
               <a:s>define function ToString(value </a:s>
               <a:s r="812">
                  <a:s>RelatedArtifactType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="814">
                  <a:s r="814">
                     <a:s r="813">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="814">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="814" locator="228:54-228:64" path="value" xsi:type="Property">
            <source localId="813" locator="228:54-228:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="812" locator="228:32-228:50" name="fhir:RelatedArtifactType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="819" locator="229:1-229:62" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="819">
               <a:s>define function ToString(value </a:s>
               <a:s r="816">
                  <a:s>RemittanceOutcome</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="818">
                  <a:s r="818">
                     <a:s r="817">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="818">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="818" locator="229:52-229:62" path="value" xsi:type="Property">
            <source localId="817" locator="229:52-229:56" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="816" locator="229:32-229:48" name="fhir:RemittanceOutcome" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="823" locator="230:1-230:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="823">
               <a:s>define function ToString(value </a:s>
               <a:s r="820">
                  <a:s>RepositoryType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="822">
                  <a:s r="822">
                     <a:s r="821">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="822">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="822" locator="230:49-230:59" path="value" xsi:type="Property">
            <source localId="821" locator="230:49-230:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="820" locator="230:32-230:45" name="fhir:RepositoryType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="827" locator="231:1-231:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="827">
               <a:s>define function ToString(value </a:s>
               <a:s r="824">
                  <a:s>RequestIntent</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="826">
                  <a:s r="826">
                     <a:s r="825">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="826">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="826" locator="231:48-231:58" path="value" xsi:type="Property">
            <source localId="825" locator="231:48-231:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="824" locator="231:32-231:44" name="fhir:RequestIntent" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="831" locator="232:1-232:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="831">
               <a:s>define function ToString(value </a:s>
               <a:s r="828">
                  <a:s>RequestPriority</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="830">
                  <a:s r="830">
                     <a:s r="829">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="830">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="830" locator="232:50-232:60" path="value" xsi:type="Property">
            <source localId="829" locator="232:50-232:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="828" locator="232:32-232:46" name="fhir:RequestPriority" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="835" locator="233:1-233:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="835">
               <a:s>define function ToString(value </a:s>
               <a:s r="832">
                  <a:s>RequestStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="834">
                  <a:s r="834">
                     <a:s r="833">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="834">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="834" locator="233:48-233:58" path="value" xsi:type="Property">
            <source localId="833" locator="233:48-233:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="832" locator="233:32-233:44" name="fhir:RequestStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="839" locator="234:1-234:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="839">
               <a:s>define function ToString(value </a:s>
               <a:s r="836">
                  <a:s>ResearchElementType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="838">
                  <a:s r="838">
                     <a:s r="837">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="838">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="838" locator="234:54-234:64" path="value" xsi:type="Property">
            <source localId="837" locator="234:54-234:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="836" locator="234:32-234:50" name="fhir:ResearchElementType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="843" locator="235:1-235:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="843">
               <a:s>define function ToString(value </a:s>
               <a:s r="840">
                  <a:s>ResearchStudyStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="842">
                  <a:s r="842">
                     <a:s r="841">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="842">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="842" locator="235:54-235:64" path="value" xsi:type="Property">
            <source localId="841" locator="235:54-235:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="840" locator="235:32-235:50" name="fhir:ResearchStudyStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="847" locator="236:1-236:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="847">
               <a:s>define function ToString(value </a:s>
               <a:s r="844">
                  <a:s>ResearchSubjectStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="846">
                  <a:s r="846">
                     <a:s r="845">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="846">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="846" locator="236:56-236:66" path="value" xsi:type="Property">
            <source localId="845" locator="236:56-236:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="844" locator="236:32-236:52" name="fhir:ResearchSubjectStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="851" locator="237:1-237:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="851">
               <a:s>define function ToString(value </a:s>
               <a:s r="848">
                  <a:s>ResourceType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="850">
                  <a:s r="850">
                     <a:s r="849">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="850">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="850" locator="237:47-237:57" path="value" xsi:type="Property">
            <source localId="849" locator="237:47-237:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="848" locator="237:32-237:43" name="fhir:ResourceType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="855" locator="238:1-238:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="855">
               <a:s>define function ToString(value </a:s>
               <a:s r="852">
                  <a:s>ResourceVersionPolicy</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="854">
                  <a:s r="854">
                     <a:s r="853">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="854">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="854" locator="238:56-238:66" path="value" xsi:type="Property">
            <source localId="853" locator="238:56-238:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="852" locator="238:32-238:52" name="fhir:ResourceVersionPolicy" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="859" locator="239:1-239:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="859">
               <a:s>define function ToString(value </a:s>
               <a:s r="856">
                  <a:s>ResponseType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="858">
                  <a:s r="858">
                     <a:s r="857">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="858">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="858" locator="239:47-239:57" path="value" xsi:type="Property">
            <source localId="857" locator="239:47-239:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="856" locator="239:32-239:43" name="fhir:ResponseType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="863" locator="240:1-240:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="863">
               <a:s>define function ToString(value </a:s>
               <a:s r="860">
                  <a:s>RestfulCapabilityMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="862">
                  <a:s r="862">
                     <a:s r="861">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="862">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="862" locator="240:56-240:66" path="value" xsi:type="Property">
            <source localId="861" locator="240:56-240:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="860" locator="240:32-240:52" name="fhir:RestfulCapabilityMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="867" locator="241:1-241:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="867">
               <a:s>define function ToString(value </a:s>
               <a:s r="864">
                  <a:s>RiskAssessmentStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="866">
                  <a:s r="866">
                     <a:s r="865">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="866">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="866" locator="241:55-241:65" path="value" xsi:type="Property">
            <source localId="865" locator="241:55-241:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="864" locator="241:32-241:51" name="fhir:RiskAssessmentStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="871" locator="242:1-242:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="871">
               <a:s>define function ToString(value </a:s>
               <a:s r="868">
                  <a:s>SPDXLicense</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="870">
                  <a:s r="870">
                     <a:s r="869">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="870">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="870" locator="242:46-242:56" path="value" xsi:type="Property">
            <source localId="869" locator="242:46-242:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="868" locator="242:32-242:42" name="fhir:SPDXLicense" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="875" locator="243:1-243:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="875">
               <a:s>define function ToString(value </a:s>
               <a:s r="872">
                  <a:s>SearchComparator</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="874">
                  <a:s r="874">
                     <a:s r="873">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="874">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="874" locator="243:51-243:61" path="value" xsi:type="Property">
            <source localId="873" locator="243:51-243:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="872" locator="243:32-243:47" name="fhir:SearchComparator" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="879" locator="244:1-244:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="879">
               <a:s>define function ToString(value </a:s>
               <a:s r="876">
                  <a:s>SearchEntryMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="878">
                  <a:s r="878">
                     <a:s r="877">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="878">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="878" locator="244:50-244:60" path="value" xsi:type="Property">
            <source localId="877" locator="244:50-244:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="876" locator="244:32-244:46" name="fhir:SearchEntryMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="883" locator="245:1-245:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="883">
               <a:s>define function ToString(value </a:s>
               <a:s r="880">
                  <a:s>SearchModifierCode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="882">
                  <a:s r="882">
                     <a:s r="881">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="882">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="882" locator="245:53-245:63" path="value" xsi:type="Property">
            <source localId="881" locator="245:53-245:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="880" locator="245:32-245:49" name="fhir:SearchModifierCode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="887" locator="246:1-246:60" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="887">
               <a:s>define function ToString(value </a:s>
               <a:s r="884">
                  <a:s>SearchParamType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="886">
                  <a:s r="886">
                     <a:s r="885">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="886">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="886" locator="246:50-246:60" path="value" xsi:type="Property">
            <source localId="885" locator="246:50-246:54" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="884" locator="246:32-246:46" name="fhir:SearchParamType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="891" locator="247:1-247:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="891">
               <a:s>define function ToString(value </a:s>
               <a:s r="888">
                  <a:s>SectionMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="890">
                  <a:s r="890">
                     <a:s r="889">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="890">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="890" locator="247:46-247:56" path="value" xsi:type="Property">
            <source localId="889" locator="247:46-247:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="888" locator="247:32-247:42" name="fhir:SectionMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="895" locator="248:1-248:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="895">
               <a:s>define function ToString(value </a:s>
               <a:s r="892">
                  <a:s>SequenceType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="894">
                  <a:s r="894">
                     <a:s r="893">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="894">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="894" locator="248:47-248:57" path="value" xsi:type="Property">
            <source localId="893" locator="248:47-248:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="892" locator="248:32-248:43" name="fhir:SequenceType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="899" locator="249:1-249:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="899">
               <a:s>define function ToString(value </a:s>
               <a:s r="896">
                  <a:s>ServiceRequestIntent</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="898">
                  <a:s r="898">
                     <a:s r="897">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="898">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="898" locator="249:55-249:65" path="value" xsi:type="Property">
            <source localId="897" locator="249:55-249:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="896" locator="249:32-249:51" name="fhir:ServiceRequestIntent" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="903" locator="250:1-250:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="903">
               <a:s>define function ToString(value </a:s>
               <a:s r="900">
                  <a:s>ServiceRequestPriority</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="902">
                  <a:s r="902">
                     <a:s r="901">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="902">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="902" locator="250:57-250:67" path="value" xsi:type="Property">
            <source localId="901" locator="250:57-250:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="900" locator="250:32-250:53" name="fhir:ServiceRequestPriority" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="907" locator="251:1-251:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="907">
               <a:s>define function ToString(value </a:s>
               <a:s r="904">
                  <a:s>ServiceRequestStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="906">
                  <a:s r="906">
                     <a:s r="905">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="906">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="906" locator="251:55-251:65" path="value" xsi:type="Property">
            <source localId="905" locator="251:55-251:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="904" locator="251:32-251:51" name="fhir:ServiceRequestStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="911" locator="252:1-252:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="911">
               <a:s>define function ToString(value </a:s>
               <a:s r="908">
                  <a:s>SlicingRules</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="910">
                  <a:s r="910">
                     <a:s r="909">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="910">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="910" locator="252:47-252:57" path="value" xsi:type="Property">
            <source localId="909" locator="252:47-252:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="908" locator="252:32-252:43" name="fhir:SlicingRules" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="915" locator="253:1-253:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="915">
               <a:s>define function ToString(value </a:s>
               <a:s r="912">
                  <a:s>SlotStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="914">
                  <a:s r="914">
                     <a:s r="913">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="914">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="914" locator="253:45-253:55" path="value" xsi:type="Property">
            <source localId="913" locator="253:45-253:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="912" locator="253:32-253:41" name="fhir:SlotStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="919" locator="254:1-254:58" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="919">
               <a:s>define function ToString(value </a:s>
               <a:s r="916">
                  <a:s>SortDirection</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="918">
                  <a:s r="918">
                     <a:s r="917">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="918">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="918" locator="254:48-254:58" path="value" xsi:type="Property">
            <source localId="917" locator="254:48-254:52" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="916" locator="254:32-254:44" name="fhir:SortDirection" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="923" locator="255:1-255:72" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="923">
               <a:s>define function ToString(value </a:s>
               <a:s r="920">
                  <a:s>SpecimenContainedPreference</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="922">
                  <a:s r="922">
                     <a:s r="921">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="922">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="922" locator="255:62-255:72" path="value" xsi:type="Property">
            <source localId="921" locator="255:62-255:66" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="920" locator="255:32-255:58" name="fhir:SpecimenContainedPreference" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="927" locator="256:1-256:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="927">
               <a:s>define function ToString(value </a:s>
               <a:s r="924">
                  <a:s>SpecimenStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="926">
                  <a:s r="926">
                     <a:s r="925">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="926">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="926" locator="256:49-256:59" path="value" xsi:type="Property">
            <source localId="925" locator="256:49-256:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="924" locator="256:32-256:45" name="fhir:SpecimenStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="931" locator="257:1-257:51" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="931">
               <a:s>define function ToString(value </a:s>
               <a:s r="928">
                  <a:s>Status</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="930">
                  <a:s r="930">
                     <a:s r="929">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="930">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="930" locator="257:41-257:51" path="value" xsi:type="Property">
            <source localId="929" locator="257:41-257:45" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="928" locator="257:32-257:37" name="fhir:Status" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="935" locator="258:1-258:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="935">
               <a:s>define function ToString(value </a:s>
               <a:s r="932">
                  <a:s>StrandType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="934">
                  <a:s r="934">
                     <a:s r="933">
                        <a:s>value</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>
         </annotation>
         <expression localId="934" locator="258:45-258:55" path="value" xsi:type="Property">
            <source localId="933" locator="258:45-258:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="932" locator="258:32-258:41" name="fhir:StrandType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="939" locator="259:1-259:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="939">
               <a:s>define function ToString(value </a:s>
               <a:s r="936">
                  <a:s>StructureDefinitionKind</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="938">
                  <a:s r="938">
                     <a:s r="937">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="938">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="938" locator="259:58-259:68" path="value" xsi:type="Property">
            <source localId="937" locator="259:58-259:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="936" locator="259:32-259:54" name="fhir:StructureDefinitionKind" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="943" locator="260:1-260:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="943">
               <a:s>define function ToString(value </a:s>
               <a:s r="940">
                  <a:s>StructureMapContextType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="942">
                  <a:s r="942">
                     <a:s r="941">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="942">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="942" locator="260:58-260:68" path="value" xsi:type="Property">
            <source localId="941" locator="260:58-260:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="940" locator="260:32-260:54" name="fhir:StructureMapContextType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="947" locator="261:1-261:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="947">
               <a:s>define function ToString(value </a:s>
               <a:s r="944">
                  <a:s>StructureMapGroupTypeMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="946">
                  <a:s r="946">
                     <a:s r="945">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="946">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="946" locator="261:60-261:70" path="value" xsi:type="Property">
            <source localId="945" locator="261:60-261:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="944" locator="261:32-261:56" name="fhir:StructureMapGroupTypeMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="951" locator="262:1-262:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="951">
               <a:s>define function ToString(value </a:s>
               <a:s r="948">
                  <a:s>StructureMapInputMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="950">
                  <a:s r="950">
                     <a:s r="949">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="950">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="950" locator="262:56-262:66" path="value" xsi:type="Property">
            <source localId="949" locator="262:56-262:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="948" locator="262:32-262:52" name="fhir:StructureMapInputMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="955" locator="263:1-263:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="955">
               <a:s>define function ToString(value </a:s>
               <a:s r="952">
                  <a:s>StructureMapModelMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="954">
                  <a:s r="954">
                     <a:s r="953">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="954">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="954" locator="263:56-263:66" path="value" xsi:type="Property">
            <source localId="953" locator="263:56-263:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="952" locator="263:32-263:52" name="fhir:StructureMapModelMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="959" locator="264:1-264:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="959">
               <a:s>define function ToString(value </a:s>
               <a:s r="956">
                  <a:s>StructureMapSourceListMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="958">
                  <a:s r="958">
                     <a:s r="957">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="958">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="958" locator="264:61-264:71" path="value" xsi:type="Property">
            <source localId="957" locator="264:61-264:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="956" locator="264:32-264:57" name="fhir:StructureMapSourceListMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="963" locator="265:1-265:71" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="963">
               <a:s>define function ToString(value </a:s>
               <a:s r="960">
                  <a:s>StructureMapTargetListMode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="962">
                  <a:s r="962">
                     <a:s r="961">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="962">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="962" locator="265:61-265:71" path="value" xsi:type="Property">
            <source localId="961" locator="265:61-265:65" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="960" locator="265:32-265:57" name="fhir:StructureMapTargetListMode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="967" locator="266:1-266:66" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="967">
               <a:s>define function ToString(value </a:s>
               <a:s r="964">
                  <a:s>StructureMapTransform</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="966">
                  <a:s r="966">
                     <a:s r="965">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="966">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="966" locator="266:56-266:66" path="value" xsi:type="Property">
            <source localId="965" locator="266:56-266:60" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="964" locator="266:32-266:52" name="fhir:StructureMapTransform" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="971" locator="267:1-267:68" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="971">
               <a:s>define function ToString(value </a:s>
               <a:s r="968">
                  <a:s>SubscriptionChannelType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="970">
                  <a:s r="970">
                     <a:s r="969">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="970">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="970" locator="267:58-267:68" path="value" xsi:type="Property">
            <source localId="969" locator="267:58-267:62" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="968" locator="267:32-267:54" name="fhir:SubscriptionChannelType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="975" locator="268:1-268:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="975">
               <a:s>define function ToString(value </a:s>
               <a:s r="972">
                  <a:s>SubscriptionStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="974">
                  <a:s r="974">
                     <a:s r="973">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="974">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="974" locator="268:53-268:63" path="value" xsi:type="Property">
            <source localId="973" locator="268:53-268:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="972" locator="268:32-268:49" name="fhir:SubscriptionStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="979" locator="269:1-269:65" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="979">
               <a:s>define function ToString(value </a:s>
               <a:s r="976">
                  <a:s>SupplyDeliveryStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="978">
                  <a:s r="978">
                     <a:s r="977">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="978">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="978" locator="269:55-269:65" path="value" xsi:type="Property">
            <source localId="977" locator="269:55-269:59" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="976" locator="269:32-269:51" name="fhir:SupplyDeliveryStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="983" locator="270:1-270:64" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="983">
               <a:s>define function ToString(value </a:s>
               <a:s r="980">
                  <a:s>SupplyRequestStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="982">
                  <a:s r="982">
                     <a:s r="981">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="982">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="982" locator="270:54-270:64" path="value" xsi:type="Property">
            <source localId="981" locator="270:54-270:58" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="980" locator="270:32-270:50" name="fhir:SupplyRequestStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="987" locator="271:1-271:69" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="987">
               <a:s>define function ToString(value </a:s>
               <a:s r="984">
                  <a:s>SystemRestfulInteraction</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="986">
                  <a:s r="986">
                     <a:s r="985">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="986">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="986" locator="271:59-271:69" path="value" xsi:type="Property">
            <source localId="985" locator="271:59-271:63" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="984" locator="271:32-271:55" name="fhir:SystemRestfulInteraction" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="991" locator="272:1-272:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="991">
               <a:s>define function ToString(value </a:s>
               <a:s r="988">
                  <a:s>TaskIntent</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="990">
                  <a:s r="990">
                     <a:s r="989">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="990">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="990" locator="272:45-272:55" path="value" xsi:type="Property">
            <source localId="989" locator="272:45-272:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="988" locator="272:32-272:41" name="fhir:TaskIntent" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="995" locator="273:1-273:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="995">
               <a:s>define function ToString(value </a:s>
               <a:s r="992">
                  <a:s>TaskPriority</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="994">
                  <a:s r="994">
                     <a:s r="993">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="994">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="994" locator="273:47-273:57" path="value" xsi:type="Property">
            <source localId="993" locator="273:47-273:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="992" locator="273:32-273:43" name="fhir:TaskPriority" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="999" locator="274:1-274:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="999">
               <a:s>define function ToString(value </a:s>
               <a:s r="996">
                  <a:s>TaskStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="998">
                  <a:s r="998">
                     <a:s r="997">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="998">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="998" locator="274:45-274:55" path="value" xsi:type="Property">
            <source localId="997" locator="274:45-274:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="996" locator="274:32-274:41" name="fhir:TaskStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1003" locator="275:1-275:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1003">
               <a:s>define function ToString(value </a:s>
               <a:s r="1000">
                  <a:s>TestReportActionResult</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1002">
                  <a:s r="1002">
                     <a:s r="1001">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1002">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1002" locator="275:57-275:67" path="value" xsi:type="Property">
            <source localId="1001" locator="275:57-275:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1000" locator="275:32-275:53" name="fhir:TestReportActionResult" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1007" locator="276:1-276:70" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1007">
               <a:s>define function ToString(value </a:s>
               <a:s r="1004">
                  <a:s>TestReportParticipantType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1006">
                  <a:s r="1006">
                     <a:s r="1005">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1006">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1006" locator="276:60-276:70" path="value" xsi:type="Property">
            <source localId="1005" locator="276:60-276:64" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1004" locator="276:32-276:56" name="fhir:TestReportParticipantType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1011" locator="277:1-277:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1011">
               <a:s>define function ToString(value </a:s>
               <a:s r="1008">
                  <a:s>TestReportResult</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1010">
                  <a:s r="1010">
                     <a:s r="1009">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1010">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1010" locator="277:51-277:61" path="value" xsi:type="Property">
            <source localId="1009" locator="277:51-277:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1008" locator="277:32-277:47" name="fhir:TestReportResult" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1015" locator="278:1-278:61" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1015">
               <a:s>define function ToString(value </a:s>
               <a:s r="1012">
                  <a:s>TestReportStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1014">
                  <a:s r="1014">
                     <a:s r="1013">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1014">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1014" locator="278:51-278:61" path="value" xsi:type="Property">
            <source localId="1013" locator="278:51-278:55" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1012" locator="278:32-278:47" name="fhir:TestReportStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1019" locator="279:1-279:72" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1019">
               <a:s>define function ToString(value </a:s>
               <a:s r="1016">
                  <a:s>TestScriptRequestMethodCode</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1018">
                  <a:s r="1018">
                     <a:s r="1017">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1018">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1018" locator="279:62-279:72" path="value" xsi:type="Property">
            <source localId="1017" locator="279:62-279:66" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1016" locator="279:32-279:58" name="fhir:TestScriptRequestMethodCode" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1023" locator="280:1-280:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1023">
               <a:s>define function ToString(value </a:s>
               <a:s r="1020">
                  <a:s>TriggerType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1022">
                  <a:s r="1022">
                     <a:s r="1021">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1022">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1022" locator="280:46-280:56" path="value" xsi:type="Property">
            <source localId="1021" locator="280:46-280:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1020" locator="280:32-280:42" name="fhir:TriggerType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1027" locator="281:1-281:63" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1027">
               <a:s>define function ToString(value </a:s>
               <a:s r="1024">
                  <a:s>TypeDerivationRule</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1026">
                  <a:s r="1026">
                     <a:s r="1025">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1026">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1026" locator="281:53-281:63" path="value" xsi:type="Property">
            <source localId="1025" locator="281:53-281:57" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1024" locator="281:32-281:49" name="fhir:TypeDerivationRule" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1031" locator="282:1-282:67" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1031">
               <a:s>define function ToString(value </a:s>
               <a:s r="1028">
                  <a:s>TypeRestfulInteraction</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1030">
                  <a:s r="1030">
                     <a:s r="1029">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1030">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1030" locator="282:57-282:67" path="value" xsi:type="Property">
            <source localId="1029" locator="282:57-282:61" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1028" locator="282:32-282:53" name="fhir:TypeRestfulInteraction" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1035" locator="283:1-283:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1035">
               <a:s>define function ToString(value </a:s>
               <a:s r="1032">
                  <a:s>UDIEntryType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1034">
                  <a:s r="1034">
                     <a:s r="1033">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1034">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1034" locator="283:47-283:57" path="value" xsi:type="Property">
            <source localId="1033" locator="283:47-283:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1032" locator="283:32-283:43" name="fhir:UDIEntryType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1039" locator="284:1-284:56" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1039">
               <a:s>define function ToString(value </a:s>
               <a:s r="1036">
                  <a:s>UnitsOfTime</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1038">
                  <a:s r="1038">
                     <a:s r="1037">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1038">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1038" locator="284:46-284:56" path="value" xsi:type="Property">
            <source localId="1037" locator="284:46-284:50" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1036" locator="284:32-284:42" name="fhir:UnitsOfTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1043" locator="285:1-285:48" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1043">
               <a:s>define function ToString(value </a:s>
               <a:s r="1040">
                  <a:s>Use</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1042">
                  <a:s r="1042">
                     <a:s r="1041">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1042">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1042" locator="285:38-285:48" path="value" xsi:type="Property">
            <source localId="1041" locator="285:38-285:42" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1040" locator="285:32-285:34" name="fhir:Use" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1047" locator="286:1-286:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1047">
               <a:s>define function ToString(value </a:s>
               <a:s r="1044">
                  <a:s>VariableType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1046">
                  <a:s r="1046">
                     <a:s r="1045">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1046">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1046" locator="286:47-286:57" path="value" xsi:type="Property">
            <source localId="1045" locator="286:47-286:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1044" locator="286:32-286:43" name="fhir:VariableType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1051" locator="287:1-287:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1051">
               <a:s>define function ToString(value </a:s>
               <a:s r="1048">
                  <a:s>VisionBase</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1050">
                  <a:s r="1050">
                     <a:s r="1049">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1050">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1050" locator="287:45-287:55" path="value" xsi:type="Property">
            <source localId="1049" locator="287:45-287:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1048" locator="287:32-287:41" name="fhir:VisionBase" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1055" locator="288:1-288:55" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1055">
               <a:s>define function ToString(value </a:s>
               <a:s r="1052">
                  <a:s>VisionEyes</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1054">
                  <a:s r="1054">
                     <a:s r="1053">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1054">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1054" locator="288:45-288:55" path="value" xsi:type="Property">
            <source localId="1053" locator="288:45-288:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1052" locator="288:32-288:41" name="fhir:VisionEyes" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1059" locator="289:1-289:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1059">
               <a:s>define function ToString(value </a:s>
               <a:s r="1056">
                  <a:s>VisionStatus</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1058">
                  <a:s r="1058">
                     <a:s r="1057">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1058">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1058" locator="289:47-289:57" path="value" xsi:type="Property">
            <source localId="1057" locator="289:47-289:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1056" locator="289:32-289:43" name="fhir:VisionStatus" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1063" locator="290:1-290:59" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1063">
               <a:s>define function ToString(value </a:s>
               <a:s r="1060">
                  <a:s>XPathUsageType</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1062">
                  <a:s r="1062">
                     <a:s r="1061">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1062">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1062" locator="290:49-290:59" path="value" xsi:type="Property">
            <source localId="1061" locator="290:49-290:53" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1060" locator="290:32-290:45" name="fhir:XPathUsageType" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1067" locator="291:1-291:57" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1067">
               <a:s>define function ToString(value </a:s>
               <a:s r="1064">
                  <a:s>base64Binary</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1066">
                  <a:s r="1066">
                     <a:s r="1065">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1066">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1066" locator="291:47-291:57" path="value" xsi:type="Property">
            <source localId="1065" locator="291:47-291:51" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1064" locator="291:32-291:43" name="fhir:base64Binary" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1071" locator="292:1-292:53" name="ToBoolean" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1071">
               <a:s>define function ToBoolean(value </a:s>
               <a:s r="1068">
                  <a:s>boolean</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1070">
                  <a:s r="1070">
                     <a:s r="1069">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1070">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1070" locator="292:43-292:53" path="value" xsi:type="Property">
            <source localId="1069" locator="292:43-292:47" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1068" locator="292:33-292:39" name="fhir:boolean" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1075" locator="293:1-293:47" name="ToDate" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1075">
               <a:s>define function ToDate(value </a:s>
               <a:s r="1072">
                  <a:s>date</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1074">
                  <a:s r="1074">
                     <a:s r="1073">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1074">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1074" locator="293:37-293:47" path="value" xsi:type="Property">
            <source localId="1073" locator="293:37-293:41" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1072" locator="293:30-293:33" name="fhir:date" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1079" locator="294:1-294:55" name="ToDateTime" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1079">
               <a:s>define function ToDateTime(value </a:s>
               <a:s r="1076">
                  <a:s>dateTime</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1078">
                  <a:s r="1078">
                     <a:s r="1077">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1078">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1078" locator="294:45-294:55" path="value" xsi:type="Property">
            <source localId="1077" locator="294:45-294:49" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1076" locator="294:34-294:41" name="fhir:dateTime" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1083" locator="295:1-295:53" name="ToDecimal" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1083">
               <a:s>define function ToDecimal(value </a:s>
               <a:s r="1080">
                  <a:s>decimal</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1082">
                  <a:s r="1082">
                     <a:s r="1081">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1082">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1082" locator="295:43-295:53" path="value" xsi:type="Property">
            <source localId="1081" locator="295:43-295:47" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1080" locator="295:33-295:39" name="fhir:decimal" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1087" locator="296:1-296:54" name="ToDateTime" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1087">
               <a:s>define function ToDateTime(value </a:s>
               <a:s r="1084">
                  <a:s>instant</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1086">
                  <a:s r="1086">
                     <a:s r="1085">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1086">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1086" locator="296:44-296:54" path="value" xsi:type="Property">
            <source localId="1085" locator="296:44-296:48" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1084" locator="296:34-296:40" name="fhir:instant" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1091" locator="297:1-297:53" name="ToInteger" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1091">
               <a:s>define function ToInteger(value </a:s>
               <a:s r="1088">
                  <a:s>integer</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1090">
                  <a:s r="1090">
                     <a:s r="1089">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1090">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1090" locator="297:43-297:53" path="value" xsi:type="Property">
            <source localId="1089" locator="297:43-297:47" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1088" locator="297:33-297:39" name="fhir:integer" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1095" locator="298:1-298:51" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1095">
               <a:s>define function ToString(value </a:s>
               <a:s r="1092">
                  <a:s>string</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1094">
                  <a:s r="1094">
                     <a:s r="1093">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1094">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1094" locator="298:41-298:51" path="value" xsi:type="Property">
            <source localId="1093" locator="298:41-298:45" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1092" locator="298:32-298:37" name="fhir:string" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1099" locator="299:1-299:47" name="ToTime" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1099">
               <a:s>define function ToTime(value </a:s>
               <a:s r="1096">
                  <a:s>time</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1098">
                  <a:s r="1098">
                     <a:s r="1097">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1098">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1098" locator="299:37-299:47" path="value" xsi:type="Property">
            <source localId="1097" locator="299:37-299:41" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1096" locator="299:30-299:33" name="fhir:time" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1103" locator="300:1-300:48" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1103">
               <a:s>define function ToString(value </a:s>
               <a:s r="1100">
                  <a:s>uri</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1102">
                  <a:s r="1102">
                     <a:s r="1101">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1102">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1102" locator="300:38-300:48" path="value" xsi:type="Property">
            <source localId="1101" locator="300:38-300:42" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1100" locator="300:32-300:34" name="fhir:uri" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1107" locator="301:1-301:50" name="ToString" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1107">
               <a:s>define function ToString(value </a:s>
               <a:s r="1104">
                  <a:s>xhtml</a:s>
               </a:s>
               <a:s>): </a:s>
               <a:s r="1106">
                  <a:s r="1106">
                     <a:s r="1105">
                        <a:s>value</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="1106">
                        <a:s>value</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1106" locator="301:40-301:50" path="value" xsi:type="Property">
            <source localId="1105" locator="301:40-301:44" name="value" xsi:type="OperandRef"/>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="1104" locator="301:32-301:36" name="fhir:xhtml" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      } ],
      "identifier" : {
         "id" : "FHIRHelpers",
         "system" : "http://fhir.org/guides/dbcg/connectathon",
         "version" : "4.0.1"
      },
      "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:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1"
         } ]
      },
      "statements" : {
         "def" : [ {
            "localId" : "14",
            "locator" : "5:1-9:58",
            "name" : "ToInterval",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "14",
                  "s" : [ {
                     "value" : [ "define function ","ToInterval","(","period"," " ]
                  }, {
                     "r" : "2",
                     "s" : [ {
                        "value" : [ "FHIR",".","Period" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n    " ]
                  }, {
                     "r" : "13",
                     "s" : [ {
                        "r" : "13",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "4",
                           "s" : [ {
                              "r" : "3",
                              "s" : [ {
                                 "value" : [ "period" ]
                              } ]
                           }, {
                              "value" : [ " is null" ]
                           } ]
                        }, {
                           "r" : "5",
                           "value" : [ " then\r\n        ","null","\r\n    else\r\n        " ]
                        }, {
                           "r" : "12",
                           "s" : [ {
                              "value" : [ "Interval[" ]
                           }, {
                              "r" : "8",
                              "s" : [ {
                                 "r" : "7",
                                 "s" : [ {
                                    "r" : "6",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "7",
                                    "s" : [ {
                                       "value" : [ "\"start\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "8",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "11",
                              "s" : [ {
                                 "r" : "10",
                                 "s" : [ {
                                    "r" : "9",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "10",
                                    "s" : [ {
                                       "value" : [ "\"end\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "11",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "]" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "13",
               "locator" : "6:5-9:58",
               "type" : "If",
               "condition" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                  "type" : "As",
                  "operand" : {
                     "localId" : "4",
                     "locator" : "6:8-6:21",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "3",
                        "locator" : "6:8-6:13",
                        "name" : "period",
                        "type" : "OperandRef"
                     }
                  }
               },
               "then" : {
                  "type" : "As",
                  "operand" : {
                     "localId" : "5",
                     "locator" : "7:9-7:12",
                     "type" : "Null"
                  },
                  "asTypeSpecifier" : {
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               },
               "else" : {
                  "localId" : "12",
                  "locator" : "9:9-9:58",
                  "lowClosed" : true,
                  "highClosed" : true,
                  "type" : "Interval",
                  "low" : {
                     "localId" : "8",
                     "locator" : "9:18-9:37",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "7",
                        "locator" : "9:18-9:31",
                        "path" : "start",
                        "type" : "Property",
                        "source" : {
                           "localId" : "6",
                           "locator" : "9:18-9:23",
                           "name" : "period",
                           "type" : "OperandRef"
                        }
                     }
                  },
                  "high" : {
                     "localId" : "11",
                     "locator" : "9:40-9:57",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "10",
                        "locator" : "9:40-9:51",
                        "path" : "end",
                        "type" : "Property",
                        "source" : {
                           "localId" : "9",
                           "locator" : "9:40-9:45",
                           "name" : "period",
                           "type" : "OperandRef"
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "period",
               "operandTypeSpecifier" : {
                  "localId" : "2",
                  "locator" : "5:35-5:45",
                  "name" : "{http://hl7.org/fhir}Period",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "27",
            "locator" : "11:1-15:82",
            "name" : "ToQuantity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "27",
                  "s" : [ {
                     "value" : [ "define function ","ToQuantity","(","quantity"," " ]
                  }, {
                     "r" : "15",
                     "s" : [ {
                        "value" : [ "FHIR",".","Quantity" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n    " ]
                  }, {
                     "r" : "26",
                     "s" : [ {
                        "r" : "26",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "17",
                           "s" : [ {
                              "r" : "16",
                              "s" : [ {
                                 "value" : [ "quantity" ]
                              } ]
                           }, {
                              "value" : [ " is null" ]
                           } ]
                        }, {
                           "r" : "18",
                           "value" : [ " then\r\n        ","null","\r\n    else\r\n        " ]
                        }, {
                           "r" : "25",
                           "s" : [ {
                              "value" : [ "System",".","Quantity"," { " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "value",": " ]
                              }, {
                                 "r" : "21",
                                 "s" : [ {
                                    "r" : "20",
                                    "s" : [ {
                                       "r" : "19",
                                       "s" : [ {
                                          "value" : [ "quantity" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "20",
                                       "s" : [ {
                                          "value" : [ "value" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "21",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "unit",": " ]
                              }, {
                                 "r" : "24",
                                 "s" : [ {
                                    "r" : "23",
                                    "s" : [ {
                                       "r" : "22",
                                       "s" : [ {
                                          "value" : [ "quantity" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "23",
                                       "s" : [ {
                                          "value" : [ "unit" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "24",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " }" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "26",
               "locator" : "12:5-15:82",
               "type" : "If",
               "condition" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                  "type" : "As",
                  "operand" : {
                     "localId" : "17",
                     "locator" : "12:8-12:23",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "16",
                        "locator" : "12:8-12:15",
                        "name" : "quantity",
                        "type" : "OperandRef"
                     }
                  }
               },
               "then" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "As",
                  "operand" : {
                     "localId" : "18",
                     "locator" : "13:9-13:12",
                     "type" : "Null"
                  }
               },
               "else" : {
                  "localId" : "25",
                  "locator" : "15:9-15:82",
                  "classType" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "Instance",
                  "element" : [ {
                     "name" : "value",
                     "value" : {
                        "localId" : "21",
                        "locator" : "15:34-15:53",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "20",
                           "locator" : "15:34-15:47",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "19",
                              "locator" : "15:34-15:41",
                              "name" : "quantity",
                              "type" : "OperandRef"
                           }
                        }
                     }
                  }, {
                     "name" : "unit",
                     "value" : {
                        "localId" : "24",
                        "locator" : "15:62-15:80",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "23",
                           "locator" : "15:62-15:74",
                           "path" : "unit",
                           "type" : "Property",
                           "source" : {
                              "localId" : "22",
                              "locator" : "15:62-15:69",
                              "name" : "quantity",
                              "type" : "OperandRef"
                           }
                        }
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "quantity",
               "operandTypeSpecifier" : {
                  "localId" : "15",
                  "locator" : "11:37-11:49",
                  "name" : "{http://hl7.org/fhir}Quantity",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "40",
            "locator" : "17:1-21:63",
            "name" : "ToInterval",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "40",
                  "s" : [ {
                     "value" : [ "define function ","ToInterval","(","range"," " ]
                  }, {
                     "r" : "28",
                     "s" : [ {
                        "value" : [ "FHIR",".","Range" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n    " ]
                  }, {
                     "r" : "39",
                     "s" : [ {
                        "r" : "39",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "30",
                           "s" : [ {
                              "r" : "29",
                              "s" : [ {
                                 "value" : [ "range" ]
                              } ]
                           }, {
                              "value" : [ " is null" ]
                           } ]
                        }, {
                           "r" : "31",
                           "value" : [ " then\r\n        ","null","\r\n    else\r\n        " ]
                        }, {
                           "r" : "38",
                           "s" : [ {
                              "value" : [ "Interval[" ]
                           }, {
                              "r" : "34",
                              "s" : [ {
                                 "value" : [ "ToQuantity","(" ]
                              }, {
                                 "r" : "33",
                                 "s" : [ {
                                    "r" : "32",
                                    "s" : [ {
                                       "value" : [ "range" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "33",
                                    "s" : [ {
                                       "value" : [ "low" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "37",
                              "s" : [ {
                                 "value" : [ "ToQuantity","(" ]
                              }, {
                                 "r" : "36",
                                 "s" : [ {
                                    "r" : "35",
                                    "s" : [ {
                                       "value" : [ "range" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "36",
                                    "s" : [ {
                                       "value" : [ "high" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ "]" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "39",
               "locator" : "18:5-21:63",
               "type" : "If",
               "condition" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                  "type" : "As",
                  "operand" : {
                     "localId" : "30",
                     "locator" : "18:8-18:20",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "29",
                        "locator" : "18:8-18:12",
                        "name" : "range",
                        "type" : "OperandRef"
                     }
                  }
               },
               "then" : {
                  "type" : "As",
                  "operand" : {
                     "localId" : "31",
                     "locator" : "19:9-19:12",
                     "type" : "Null"
                  },
                  "asTypeSpecifier" : {
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               },
               "else" : {
                  "localId" : "38",
                  "locator" : "21:9-21:63",
                  "lowClosed" : true,
                  "highClosed" : true,
                  "type" : "Interval",
                  "low" : {
                     "localId" : "34",
                     "locator" : "21:18-21:38",
                     "name" : "ToQuantity",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "33",
                        "locator" : "21:29-21:37",
                        "path" : "low",
                        "type" : "Property",
                        "source" : {
                           "localId" : "32",
                           "locator" : "21:29-21:33",
                           "name" : "range",
                           "type" : "OperandRef"
                        }
                     } ]
                  },
                  "high" : {
                     "localId" : "37",
                     "locator" : "21:41-21:62",
                     "name" : "ToQuantity",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "36",
                        "locator" : "21:52-21:61",
                        "path" : "high",
                        "type" : "Property",
                        "source" : {
                           "localId" : "35",
                           "locator" : "21:52-21:56",
                           "name" : "range",
                           "type" : "OperandRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "range",
               "operandTypeSpecifier" : {
                  "localId" : "28",
                  "locator" : "17:34-17:43",
                  "name" : "{http://hl7.org/fhir}Range",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "59",
            "locator" : "23:1-32:9",
            "name" : "ToCode",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "59",
                  "s" : [ {
                     "value" : [ "define function ","ToCode","(","coding"," " ]
                  }, {
                     "r" : "41",
                     "s" : [ {
                        "value" : [ "FHIR",".","Coding" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n    " ]
                  }, {
                     "r" : "58",
                     "s" : [ {
                        "r" : "58",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "43",
                           "s" : [ {
                              "r" : "42",
                              "s" : [ {
                                 "value" : [ "coding" ]
                              } ]
                           }, {
                              "value" : [ " is null" ]
                           } ]
                        }, {
                           "r" : "44",
                           "value" : [ " then\r\n        ","null","\r\n    else\r\n        " ]
                        }, {
                           "r" : "57",
                           "s" : [ {
                              "value" : [ "System",".","Code"," {\r\n          " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "code",": " ]
                              }, {
                                 "r" : "47",
                                 "s" : [ {
                                    "r" : "46",
                                    "s" : [ {
                                       "r" : "45",
                                       "s" : [ {
                                          "value" : [ "coding" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "46",
                                       "s" : [ {
                                          "value" : [ "code" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "47",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\r\n          " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "system",": " ]
                              }, {
                                 "r" : "50",
                                 "s" : [ {
                                    "r" : "49",
                                    "s" : [ {
                                       "r" : "48",
                                       "s" : [ {
                                          "value" : [ "coding" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "49",
                                       "s" : [ {
                                          "value" : [ "system" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "50",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\r\n          " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "version",": " ]
                              }, {
                                 "r" : "53",
                                 "s" : [ {
                                    "r" : "52",
                                    "s" : [ {
                                       "r" : "51",
                                       "s" : [ {
                                          "value" : [ "coding" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "52",
                                       "s" : [ {
                                          "value" : [ "version" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "53",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\r\n          " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "display",": " ]
                              }, {
                                 "r" : "56",
                                 "s" : [ {
                                    "r" : "55",
                                    "s" : [ {
                                       "r" : "54",
                                       "s" : [ {
                                          "value" : [ "coding" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "55",
                                       "s" : [ {
                                          "value" : [ "display" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "56",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n        }" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "58",
               "locator" : "24:5-32:9",
               "type" : "If",
               "condition" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                  "type" : "As",
                  "operand" : {
                     "localId" : "43",
                     "locator" : "24:8-24:21",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "42",
                        "locator" : "24:8-24:13",
                        "name" : "coding",
                        "type" : "OperandRef"
                     }
                  }
               },
               "then" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "As",
                  "operand" : {
                     "localId" : "44",
                     "locator" : "25:9-25:12",
                     "type" : "Null"
                  }
               },
               "else" : {
                  "localId" : "57",
                  "locator" : "27:9-32:9",
                  "classType" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "Instance",
                  "element" : [ {
                     "name" : "code",
                     "value" : {
                        "localId" : "47",
                        "locator" : "28:17-28:33",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "46",
                           "locator" : "28:17-28:27",
                           "path" : "code",
                           "type" : "Property",
                           "source" : {
                              "localId" : "45",
                              "locator" : "28:17-28:22",
                              "name" : "coding",
                              "type" : "OperandRef"
                           }
                        }
                     }
                  }, {
                     "name" : "system",
                     "value" : {
                        "localId" : "50",
                        "locator" : "29:19-29:37",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "49",
                           "locator" : "29:19-29:31",
                           "path" : "system",
                           "type" : "Property",
                           "source" : {
                              "localId" : "48",
                              "locator" : "29:19-29:24",
                              "name" : "coding",
                              "type" : "OperandRef"
                           }
                        }
                     }
                  }, {
                     "name" : "version",
                     "value" : {
                        "localId" : "53",
                        "locator" : "30:20-30:39",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "52",
                           "locator" : "30:20-30:33",
                           "path" : "version",
                           "type" : "Property",
                           "source" : {
                              "localId" : "51",
                              "locator" : "30:20-30:25",
                              "name" : "coding",
                              "type" : "OperandRef"
                           }
                        }
                     }
                  }, {
                     "name" : "display",
                     "value" : {
                        "localId" : "56",
                        "locator" : "31:20-31:39",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "55",
                           "locator" : "31:20-31:33",
                           "path" : "display",
                           "type" : "Property",
                           "source" : {
                              "localId" : "54",
                              "locator" : "31:20-31:25",
                              "name" : "coding",
                              "type" : "OperandRef"
                           }
                        }
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "coding",
               "operandTypeSpecifier" : {
                  "localId" : "41",
                  "locator" : "23:31-23:41",
                  "name" : "{http://hl7.org/fhir}Coding",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "75",
            "locator" : "34:1-41:9",
            "name" : "ToConcept",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "75",
                  "s" : [ {
                     "value" : [ "define function ","ToConcept","(","concept"," " ]
                  }, {
                     "r" : "60",
                     "s" : [ {
                        "value" : [ "FHIR",".","CodeableConcept" ]
                     } ]
                  }, {
                     "value" : [ "):\r\n    " ]
                  }, {
                     "r" : "74",
                     "s" : [ {
                        "r" : "74",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "62",
                           "s" : [ {
                              "r" : "61",
                              "s" : [ {
                                 "value" : [ "concept" ]
                              } ]
                           }, {
                              "value" : [ " is null" ]
                           } ]
                        }, {
                           "r" : "63",
                           "value" : [ " then\r\n        ","null","\r\n    else\r\n        " ]
                        }, {
                           "r" : "73",
                           "s" : [ {
                              "value" : [ "System",".","Concept"," {\r\n            " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "codes",": " ]
                              }, {
                                 "r" : "69",
                                 "s" : [ {
                                    "s" : [ {
                                       "r" : "65",
                                       "s" : [ {
                                          "r" : "64",
                                          "s" : [ {
                                             "s" : [ {
                                                "value" : [ "concept",".","coding" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","C" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " " ]
                                 }, {
                                    "r" : "68",
                                    "s" : [ {
                                       "value" : [ "return " ]
                                    }, {
                                       "r" : "67",
                                       "s" : [ {
                                          "value" : [ "ToCode","(" ]
                                       }, {
                                          "r" : "66",
                                          "s" : [ {
                                             "value" : [ "C" ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\r\n            " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "display",": " ]
                              }, {
                                 "r" : "72",
                                 "s" : [ {
                                    "r" : "71",
                                    "s" : [ {
                                       "r" : "70",
                                       "s" : [ {
                                          "value" : [ "concept" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "71",
                                       "s" : [ {
                                          "value" : [ "text" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "72",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\r\n        }" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "74",
               "locator" : "35:5-41:9",
               "type" : "If",
               "condition" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                  "type" : "As",
                  "operand" : {
                     "localId" : "62",
                     "locator" : "35:8-35:22",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "61",
                        "locator" : "35:8-35:14",
                        "name" : "concept",
                        "type" : "OperandRef"
                     }
                  }
               },
               "then" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Concept",
                  "type" : "As",
                  "operand" : {
                     "localId" : "63",
                     "locator" : "36:9-36:12",
                     "type" : "Null"
                  }
               },
               "else" : {
                  "localId" : "73",
                  "locator" : "38:9-41:9",
                  "classType" : "{urn:hl7-org:elm-types:r1}Concept",
                  "type" : "Instance",
                  "element" : [ {
                     "name" : "codes",
                     "value" : {
                        "localId" : "69",
                        "locator" : "39:20-39:52",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "65",
                           "locator" : "39:20-39:35",
                           "alias" : "C",
                           "expression" : {
                              "localId" : "64",
                              "locator" : "39:20-39:33",
                              "path" : "coding",
                              "type" : "Property",
                              "source" : {
                                 "name" : "concept",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "return" : {
                           "localId" : "68",
                           "locator" : "39:37-39:52",
                           "expression" : {
                              "localId" : "67",
                              "locator" : "39:44-39:52",
                              "name" : "ToCode",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "66",
                                 "locator" : "39:51",
                                 "name" : "C",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  }, {
                     "name" : "display",
                     "value" : {
                        "localId" : "72",
                        "locator" : "40:22-40:39",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "71",
                           "locator" : "40:22-40:33",
                           "path" : "text",
                           "type" : "Property",
                           "source" : {
                              "localId" : "70",
                              "locator" : "40:22-40:28",
                              "name" : "concept",
                              "type" : "OperandRef"
                           }
                        }
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "concept",
               "operandTypeSpecifier" : {
                  "localId" : "60",
                  "locator" : "34:35-34:54",
                  "name" : "{http://hl7.org/fhir}CodeableConcept",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "79",
            "locator" : "44:1-44:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "79",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "76",
                     "s" : [ {
                        "value" : [ "AccountStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "78",
                     "s" : [ {
                        "r" : "78",
                        "s" : [ {
                           "r" : "77",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "78",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "78",
               "locator" : "44:48-44:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "77",
                  "locator" : "44:48-44:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "76",
                  "locator" : "44:32-44:44",
                  "name" : "{http://hl7.org/fhir}AccountStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "83",
            "locator" : "45:1-45:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "83",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "80",
                     "s" : [ {
                        "value" : [ "ActionCardinalityBehavior" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "82",
                     "s" : [ {
                        "r" : "82",
                        "s" : [ {
                           "r" : "81",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "82",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "82",
               "locator" : "45:60-45:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "81",
                  "locator" : "45:60-45:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "80",
                  "locator" : "45:32-45:56",
                  "name" : "{http://hl7.org/fhir}ActionCardinalityBehavior",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "87",
            "locator" : "46:1-46:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "87",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "84",
                     "s" : [ {
                        "value" : [ "ActionConditionKind" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "86",
                     "s" : [ {
                        "r" : "86",
                        "s" : [ {
                           "r" : "85",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "86",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "86",
               "locator" : "46:54-46:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "85",
                  "locator" : "46:54-46:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "84",
                  "locator" : "46:32-46:50",
                  "name" : "{http://hl7.org/fhir}ActionConditionKind",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "91",
            "locator" : "47:1-47:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "91",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "88",
                     "s" : [ {
                        "value" : [ "ActionGroupingBehavior" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "90",
                     "s" : [ {
                        "r" : "90",
                        "s" : [ {
                           "r" : "89",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "90",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "90",
               "locator" : "47:57-47:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "89",
                  "locator" : "47:57-47:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "88",
                  "locator" : "47:32-47:53",
                  "name" : "{http://hl7.org/fhir}ActionGroupingBehavior",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "95",
            "locator" : "48:1-48:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "95",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "92",
                     "s" : [ {
                        "value" : [ "ActionParticipantType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "94",
                     "s" : [ {
                        "r" : "94",
                        "s" : [ {
                           "r" : "93",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "94",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "94",
               "locator" : "48:56-48:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "93",
                  "locator" : "48:56-48:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "92",
                  "locator" : "48:32-48:52",
                  "name" : "{http://hl7.org/fhir}ActionParticipantType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "99",
            "locator" : "49:1-49:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "99",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "96",
                     "s" : [ {
                        "value" : [ "ActionPrecheckBehavior" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "98",
                     "s" : [ {
                        "r" : "98",
                        "s" : [ {
                           "r" : "97",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "98",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "98",
               "locator" : "49:57-49:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "97",
                  "locator" : "49:57-49:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "96",
                  "locator" : "49:32-49:53",
                  "name" : "{http://hl7.org/fhir}ActionPrecheckBehavior",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "103",
            "locator" : "50:1-50:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "103",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "100",
                     "s" : [ {
                        "value" : [ "ActionRelationshipType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "102",
                     "s" : [ {
                        "r" : "102",
                        "s" : [ {
                           "r" : "101",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "102",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "102",
               "locator" : "50:57-50:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "101",
                  "locator" : "50:57-50:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "100",
                  "locator" : "50:32-50:53",
                  "name" : "{http://hl7.org/fhir}ActionRelationshipType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "107",
            "locator" : "51:1-51:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "107",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "104",
                     "s" : [ {
                        "value" : [ "ActionRequiredBehavior" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "106",
                     "s" : [ {
                        "r" : "106",
                        "s" : [ {
                           "r" : "105",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "106",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "106",
               "locator" : "51:57-51:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "105",
                  "locator" : "51:57-51:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "104",
                  "locator" : "51:32-51:53",
                  "name" : "{http://hl7.org/fhir}ActionRequiredBehavior",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "111",
            "locator" : "52:1-52:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "111",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "108",
                     "s" : [ {
                        "value" : [ "ActionSelectionBehavior" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "110",
                     "s" : [ {
                        "r" : "110",
                        "s" : [ {
                           "r" : "109",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "110",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "110",
               "locator" : "52:58-52:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "109",
                  "locator" : "52:58-52:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "108",
                  "locator" : "52:32-52:54",
                  "name" : "{http://hl7.org/fhir}ActionSelectionBehavior",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "115",
            "locator" : "53:1-53:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "115",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "112",
                     "s" : [ {
                        "value" : [ "ActivityDefinitionKind" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "114",
                     "s" : [ {
                        "r" : "114",
                        "s" : [ {
                           "r" : "113",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "114",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "114",
               "locator" : "53:57-53:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "113",
                  "locator" : "53:57-53:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "112",
                  "locator" : "53:32-53:53",
                  "name" : "{http://hl7.org/fhir}ActivityDefinitionKind",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "119",
            "locator" : "54:1-54:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "119",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "116",
                     "s" : [ {
                        "value" : [ "ActivityParticipantType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "118",
                     "s" : [ {
                        "r" : "118",
                        "s" : [ {
                           "r" : "117",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "118",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "118",
               "locator" : "54:58-54:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "117",
                  "locator" : "54:58-54:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "116",
                  "locator" : "54:32-54:54",
                  "name" : "{http://hl7.org/fhir}ActivityParticipantType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "123",
            "locator" : "55:1-55:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "123",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "120",
                     "s" : [ {
                        "value" : [ "AddressType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "122",
                     "s" : [ {
                        "r" : "122",
                        "s" : [ {
                           "r" : "121",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "122",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "122",
               "locator" : "55:46-55:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "121",
                  "locator" : "55:46-55:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "120",
                  "locator" : "55:32-55:42",
                  "name" : "{http://hl7.org/fhir}AddressType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "127",
            "locator" : "56:1-56:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "127",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "124",
                     "s" : [ {
                        "value" : [ "AddressUse" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "126",
                     "s" : [ {
                        "r" : "126",
                        "s" : [ {
                           "r" : "125",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "126",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "126",
               "locator" : "56:45-56:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "125",
                  "locator" : "56:45-56:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "124",
                  "locator" : "56:32-56:41",
                  "name" : "{http://hl7.org/fhir}AddressUse",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "131",
            "locator" : "57:1-57:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "131",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "128",
                     "s" : [ {
                        "value" : [ "AdministrativeGender" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "130",
                     "s" : [ {
                        "r" : "130",
                        "s" : [ {
                           "r" : "129",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "130",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "130",
               "locator" : "57:55-57:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "129",
                  "locator" : "57:55-57:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "128",
                  "locator" : "57:32-57:51",
                  "name" : "{http://hl7.org/fhir}AdministrativeGender",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "135",
            "locator" : "58:1-58:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "135",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "132",
                     "s" : [ {
                        "value" : [ "AdverseEventActuality" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "134",
                     "s" : [ {
                        "r" : "134",
                        "s" : [ {
                           "r" : "133",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "134",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "134",
               "locator" : "58:56-58:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "133",
                  "locator" : "58:56-58:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "132",
                  "locator" : "58:32-58:52",
                  "name" : "{http://hl7.org/fhir}AdverseEventActuality",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "139",
            "locator" : "59:1-59:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "139",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "136",
                     "s" : [ {
                        "value" : [ "AggregationMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "138",
                     "s" : [ {
                        "r" : "138",
                        "s" : [ {
                           "r" : "137",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "138",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "138",
               "locator" : "59:50-59:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "137",
                  "locator" : "59:50-59:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "136",
                  "locator" : "59:32-59:46",
                  "name" : "{http://hl7.org/fhir}AggregationMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "143",
            "locator" : "60:1-60:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "143",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "140",
                     "s" : [ {
                        "value" : [ "AllergyIntoleranceCategory" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "142",
                     "s" : [ {
                        "r" : "142",
                        "s" : [ {
                           "r" : "141",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "142",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "142",
               "locator" : "60:61-60:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "141",
                  "locator" : "60:61-60:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "140",
                  "locator" : "60:32-60:57",
                  "name" : "{http://hl7.org/fhir}AllergyIntoleranceCategory",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "147",
            "locator" : "61:1-61:74",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "147",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "144",
                     "s" : [ {
                        "value" : [ "AllergyIntoleranceCriticality" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "146",
                     "s" : [ {
                        "r" : "146",
                        "s" : [ {
                           "r" : "145",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "146",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "146",
               "locator" : "61:64-61:74",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "145",
                  "locator" : "61:64-61:68",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "144",
                  "locator" : "61:32-61:60",
                  "name" : "{http://hl7.org/fhir}AllergyIntoleranceCriticality",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "151",
            "locator" : "62:1-62:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "151",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "148",
                     "s" : [ {
                        "value" : [ "AllergyIntoleranceSeverity" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "150",
                     "s" : [ {
                        "r" : "150",
                        "s" : [ {
                           "r" : "149",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "150",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "150",
               "locator" : "62:61-62:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "149",
                  "locator" : "62:61-62:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "148",
                  "locator" : "62:32-62:57",
                  "name" : "{http://hl7.org/fhir}AllergyIntoleranceSeverity",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "155",
            "locator" : "63:1-63:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "155",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "152",
                     "s" : [ {
                        "value" : [ "AllergyIntoleranceType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "154",
                     "s" : [ {
                        "r" : "154",
                        "s" : [ {
                           "r" : "153",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "154",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "154",
               "locator" : "63:57-63:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "153",
                  "locator" : "63:57-63:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "152",
                  "locator" : "63:32-63:53",
                  "name" : "{http://hl7.org/fhir}AllergyIntoleranceType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "159",
            "locator" : "64:1-64:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "159",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "156",
                     "s" : [ {
                        "value" : [ "AppointmentStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "158",
                     "s" : [ {
                        "r" : "158",
                        "s" : [ {
                           "r" : "157",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "158",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "158",
               "locator" : "64:52-64:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "157",
                  "locator" : "64:52-64:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "156",
                  "locator" : "64:32-64:48",
                  "name" : "{http://hl7.org/fhir}AppointmentStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "163",
            "locator" : "65:1-65:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "163",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "160",
                     "s" : [ {
                        "value" : [ "AssertionDirectionType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "162",
                     "s" : [ {
                        "r" : "162",
                        "s" : [ {
                           "r" : "161",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "162",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "162",
               "locator" : "65:57-65:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "161",
                  "locator" : "65:57-65:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "160",
                  "locator" : "65:32-65:53",
                  "name" : "{http://hl7.org/fhir}AssertionDirectionType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "167",
            "locator" : "66:1-66:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "167",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "164",
                     "s" : [ {
                        "value" : [ "AssertionOperatorType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "166",
                     "s" : [ {
                        "r" : "166",
                        "s" : [ {
                           "r" : "165",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "166",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "166",
               "locator" : "66:56-66:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "165",
                  "locator" : "66:56-66:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "164",
                  "locator" : "66:32-66:52",
                  "name" : "{http://hl7.org/fhir}AssertionOperatorType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "171",
            "locator" : "67:1-67:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "171",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "168",
                     "s" : [ {
                        "value" : [ "AssertionResponseTypes" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "170",
                     "s" : [ {
                        "r" : "170",
                        "s" : [ {
                           "r" : "169",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "170",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "170",
               "locator" : "67:57-67:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "169",
                  "locator" : "67:57-67:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "168",
                  "locator" : "67:32-67:53",
                  "name" : "{http://hl7.org/fhir}AssertionResponseTypes",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "175",
            "locator" : "68:1-68:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "175",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "172",
                     "s" : [ {
                        "value" : [ "AuditEventAction" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "174",
                     "s" : [ {
                        "r" : "174",
                        "s" : [ {
                           "r" : "173",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "174",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "174",
               "locator" : "68:51-68:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "173",
                  "locator" : "68:51-68:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "172",
                  "locator" : "68:32-68:47",
                  "name" : "{http://hl7.org/fhir}AuditEventAction",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "179",
            "locator" : "69:1-69:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "179",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "176",
                     "s" : [ {
                        "value" : [ "AuditEventAgentNetworkType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "178",
                     "s" : [ {
                        "r" : "178",
                        "s" : [ {
                           "r" : "177",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "178",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "178",
               "locator" : "69:61-69:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "177",
                  "locator" : "69:61-69:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "176",
                  "locator" : "69:32-69:57",
                  "name" : "{http://hl7.org/fhir}AuditEventAgentNetworkType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "183",
            "locator" : "70:1-70:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "183",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "180",
                     "s" : [ {
                        "value" : [ "AuditEventOutcome" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "182",
                     "s" : [ {
                        "r" : "182",
                        "s" : [ {
                           "r" : "181",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "182",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "182",
               "locator" : "70:52-70:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "181",
                  "locator" : "70:52-70:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "180",
                  "locator" : "70:32-70:48",
                  "name" : "{http://hl7.org/fhir}AuditEventOutcome",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "187",
            "locator" : "71:1-71:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "187",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "184",
                     "s" : [ {
                        "value" : [ "BindingStrength" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "186",
                     "s" : [ {
                        "r" : "186",
                        "s" : [ {
                           "r" : "185",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "186",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "186",
               "locator" : "71:50-71:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "185",
                  "locator" : "71:50-71:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "184",
                  "locator" : "71:32-71:46",
                  "name" : "{http://hl7.org/fhir}BindingStrength",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "191",
            "locator" : "72:1-72:79",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "191",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "188",
                     "s" : [ {
                        "value" : [ "BiologicallyDerivedProductCategory" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "190",
                     "s" : [ {
                        "r" : "190",
                        "s" : [ {
                           "r" : "189",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "190",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "190",
               "locator" : "72:69-72:79",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "189",
                  "locator" : "72:69-72:73",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "188",
                  "locator" : "72:32-72:65",
                  "name" : "{http://hl7.org/fhir}BiologicallyDerivedProductCategory",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "195",
            "locator" : "73:1-73:77",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "195",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "192",
                     "s" : [ {
                        "value" : [ "BiologicallyDerivedProductStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "194",
                     "s" : [ {
                        "r" : "194",
                        "s" : [ {
                           "r" : "193",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "194",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "194",
               "locator" : "73:67-73:77",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "193",
                  "locator" : "73:67-73:71",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "192",
                  "locator" : "73:32-73:63",
                  "name" : "{http://hl7.org/fhir}BiologicallyDerivedProductStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "199",
            "locator" : "74:1-74:83",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "199",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "196",
                     "s" : [ {
                        "value" : [ "BiologicallyDerivedProductStorageScale" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "198",
                     "s" : [ {
                        "r" : "198",
                        "s" : [ {
                           "r" : "197",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "198",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "198",
               "locator" : "74:73-74:83",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "197",
                  "locator" : "74:73-74:77",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "196",
                  "locator" : "74:32-74:69",
                  "name" : "{http://hl7.org/fhir}BiologicallyDerivedProductStorageScale",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "203",
            "locator" : "75:1-75:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "203",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "200",
                     "s" : [ {
                        "value" : [ "BundleType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "202",
                     "s" : [ {
                        "r" : "202",
                        "s" : [ {
                           "r" : "201",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "202",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "202",
               "locator" : "75:45-75:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "201",
                  "locator" : "75:45-75:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "200",
                  "locator" : "75:32-75:41",
                  "name" : "{http://hl7.org/fhir}BundleType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "207",
            "locator" : "76:1-76:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "207",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "204",
                     "s" : [ {
                        "value" : [ "CapabilityStatementKind" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "206",
                     "s" : [ {
                        "r" : "206",
                        "s" : [ {
                           "r" : "205",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "206",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "206",
               "locator" : "76:58-76:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "205",
                  "locator" : "76:58-76:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "204",
                  "locator" : "76:32-76:54",
                  "name" : "{http://hl7.org/fhir}CapabilityStatementKind",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "211",
            "locator" : "77:1-77:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "211",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "208",
                     "s" : [ {
                        "value" : [ "CarePlanActivityKind" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "210",
                     "s" : [ {
                        "r" : "210",
                        "s" : [ {
                           "r" : "209",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "210",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "210",
               "locator" : "77:55-77:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "209",
                  "locator" : "77:55-77:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "208",
                  "locator" : "77:32-77:51",
                  "name" : "{http://hl7.org/fhir}CarePlanActivityKind",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "215",
            "locator" : "78:1-78:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "215",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "212",
                     "s" : [ {
                        "value" : [ "CarePlanActivityStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "214",
                     "s" : [ {
                        "r" : "214",
                        "s" : [ {
                           "r" : "213",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "214",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "214",
               "locator" : "78:57-78:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "213",
                  "locator" : "78:57-78:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "212",
                  "locator" : "78:32-78:53",
                  "name" : "{http://hl7.org/fhir}CarePlanActivityStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "219",
            "locator" : "79:1-79:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "219",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "216",
                     "s" : [ {
                        "value" : [ "CarePlanIntent" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "218",
                     "s" : [ {
                        "r" : "218",
                        "s" : [ {
                           "r" : "217",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "218",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "218",
               "locator" : "79:49-79:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "217",
                  "locator" : "79:49-79:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "216",
                  "locator" : "79:32-79:45",
                  "name" : "{http://hl7.org/fhir}CarePlanIntent",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "223",
            "locator" : "80:1-80:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "223",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "220",
                     "s" : [ {
                        "value" : [ "CarePlanStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "222",
                     "s" : [ {
                        "r" : "222",
                        "s" : [ {
                           "r" : "221",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "222",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "222",
               "locator" : "80:49-80:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "221",
                  "locator" : "80:49-80:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "220",
                  "locator" : "80:32-80:45",
                  "name" : "{http://hl7.org/fhir}CarePlanStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "227",
            "locator" : "81:1-81:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "227",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "224",
                     "s" : [ {
                        "value" : [ "CareTeamStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "226",
                     "s" : [ {
                        "r" : "226",
                        "s" : [ {
                           "r" : "225",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "226",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "226",
               "locator" : "81:49-81:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "225",
                  "locator" : "81:49-81:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "224",
                  "locator" : "81:32-81:45",
                  "name" : "{http://hl7.org/fhir}CareTeamStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "231",
            "locator" : "82:1-82:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "231",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "228",
                     "s" : [ {
                        "value" : [ "CatalogEntryRelationType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "230",
                     "s" : [ {
                        "r" : "230",
                        "s" : [ {
                           "r" : "229",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "230",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "230",
               "locator" : "82:59-82:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "229",
                  "locator" : "82:59-82:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "228",
                  "locator" : "82:32-82:55",
                  "name" : "{http://hl7.org/fhir}CatalogEntryRelationType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "235",
            "locator" : "83:1-83:83",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "235",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "232",
                     "s" : [ {
                        "value" : [ "ChargeItemDefinitionPriceComponentType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "234",
                     "s" : [ {
                        "r" : "234",
                        "s" : [ {
                           "r" : "233",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "234",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "234",
               "locator" : "83:73-83:83",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "233",
                  "locator" : "83:73-83:77",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "232",
                  "locator" : "83:32-83:69",
                  "name" : "{http://hl7.org/fhir}ChargeItemDefinitionPriceComponentType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "239",
            "locator" : "84:1-84:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "239",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "236",
                     "s" : [ {
                        "value" : [ "ChargeItemStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "238",
                     "s" : [ {
                        "r" : "238",
                        "s" : [ {
                           "r" : "237",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "238",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "238",
               "locator" : "84:51-84:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "237",
                  "locator" : "84:51-84:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "236",
                  "locator" : "84:32-84:47",
                  "name" : "{http://hl7.org/fhir}ChargeItemStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "243",
            "locator" : "85:1-85:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "243",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "240",
                     "s" : [ {
                        "value" : [ "ClaimResponseStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "242",
                     "s" : [ {
                        "r" : "242",
                        "s" : [ {
                           "r" : "241",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "242",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "242",
               "locator" : "85:54-85:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "241",
                  "locator" : "85:54-85:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "240",
                  "locator" : "85:32-85:50",
                  "name" : "{http://hl7.org/fhir}ClaimResponseStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "247",
            "locator" : "86:1-86:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "247",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "244",
                     "s" : [ {
                        "value" : [ "ClaimStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "246",
                     "s" : [ {
                        "r" : "246",
                        "s" : [ {
                           "r" : "245",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "246",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "246",
               "locator" : "86:46-86:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "245",
                  "locator" : "86:46-86:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "244",
                  "locator" : "86:32-86:42",
                  "name" : "{http://hl7.org/fhir}ClaimStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "251",
            "locator" : "87:1-87:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "251",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "248",
                     "s" : [ {
                        "value" : [ "ClinicalImpressionStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "250",
                     "s" : [ {
                        "r" : "250",
                        "s" : [ {
                           "r" : "249",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "250",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "250",
               "locator" : "87:59-87:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "249",
                  "locator" : "87:59-87:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "248",
                  "locator" : "87:32-87:55",
                  "name" : "{http://hl7.org/fhir}ClinicalImpressionStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "255",
            "locator" : "88:1-88:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "255",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "252",
                     "s" : [ {
                        "value" : [ "CodeSearchSupport" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "254",
                     "s" : [ {
                        "r" : "254",
                        "s" : [ {
                           "r" : "253",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "254",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "254",
               "locator" : "88:52-88:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "253",
                  "locator" : "88:52-88:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "252",
                  "locator" : "88:32-88:48",
                  "name" : "{http://hl7.org/fhir}CodeSearchSupport",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "259",
            "locator" : "89:1-89:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "259",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "256",
                     "s" : [ {
                        "value" : [ "CodeSystemContentMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "258",
                     "s" : [ {
                        "r" : "258",
                        "s" : [ {
                           "r" : "257",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "258",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "258",
               "locator" : "89:56-89:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "257",
                  "locator" : "89:56-89:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "256",
                  "locator" : "89:32-89:52",
                  "name" : "{http://hl7.org/fhir}CodeSystemContentMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "263",
            "locator" : "90:1-90:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "263",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "260",
                     "s" : [ {
                        "value" : [ "CodeSystemHierarchyMeaning" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "262",
                     "s" : [ {
                        "r" : "262",
                        "s" : [ {
                           "r" : "261",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "262",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "262",
               "locator" : "90:61-90:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "261",
                  "locator" : "90:61-90:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "260",
                  "locator" : "90:32-90:57",
                  "name" : "{http://hl7.org/fhir}CodeSystemHierarchyMeaning",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "267",
            "locator" : "91:1-91:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "267",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "264",
                     "s" : [ {
                        "value" : [ "CommunicationPriority" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "266",
                     "s" : [ {
                        "r" : "266",
                        "s" : [ {
                           "r" : "265",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "266",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "266",
               "locator" : "91:56-91:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "265",
                  "locator" : "91:56-91:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "264",
                  "locator" : "91:32-91:52",
                  "name" : "{http://hl7.org/fhir}CommunicationPriority",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "271",
            "locator" : "92:1-92:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "271",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "268",
                     "s" : [ {
                        "value" : [ "CommunicationRequestStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "270",
                     "s" : [ {
                        "r" : "270",
                        "s" : [ {
                           "r" : "269",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "270",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "270",
               "locator" : "92:61-92:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "269",
                  "locator" : "92:61-92:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "268",
                  "locator" : "92:32-92:57",
                  "name" : "{http://hl7.org/fhir}CommunicationRequestStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "275",
            "locator" : "93:1-93:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "275",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "272",
                     "s" : [ {
                        "value" : [ "CommunicationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "274",
                     "s" : [ {
                        "r" : "274",
                        "s" : [ {
                           "r" : "273",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "274",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "274",
               "locator" : "93:54-93:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "273",
                  "locator" : "93:54-93:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "272",
                  "locator" : "93:32-93:50",
                  "name" : "{http://hl7.org/fhir}CommunicationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "279",
            "locator" : "94:1-94:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "279",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "276",
                     "s" : [ {
                        "value" : [ "CompartmentCode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "278",
                     "s" : [ {
                        "r" : "278",
                        "s" : [ {
                           "r" : "277",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "278",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "278",
               "locator" : "94:50-94:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "277",
                  "locator" : "94:50-94:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "276",
                  "locator" : "94:32-94:46",
                  "name" : "{http://hl7.org/fhir}CompartmentCode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "283",
            "locator" : "95:1-95:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "283",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "280",
                     "s" : [ {
                        "value" : [ "CompartmentType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "282",
                     "s" : [ {
                        "r" : "282",
                        "s" : [ {
                           "r" : "281",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "282",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "282",
               "locator" : "95:50-95:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "281",
                  "locator" : "95:50-95:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "280",
                  "locator" : "95:32-95:46",
                  "name" : "{http://hl7.org/fhir}CompartmentType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "287",
            "locator" : "96:1-96:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "287",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "284",
                     "s" : [ {
                        "value" : [ "CompositionAttestationMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "286",
                     "s" : [ {
                        "r" : "286",
                        "s" : [ {
                           "r" : "285",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "286",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "286",
               "locator" : "96:61-96:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "285",
                  "locator" : "96:61-96:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "284",
                  "locator" : "96:32-96:57",
                  "name" : "{http://hl7.org/fhir}CompositionAttestationMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "291",
            "locator" : "97:1-97:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "291",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "288",
                     "s" : [ {
                        "value" : [ "CompositionStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "290",
                     "s" : [ {
                        "r" : "290",
                        "s" : [ {
                           "r" : "289",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "290",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "290",
               "locator" : "97:52-97:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "289",
                  "locator" : "97:52-97:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "288",
                  "locator" : "97:32-97:48",
                  "name" : "{http://hl7.org/fhir}CompositionStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "295",
            "locator" : "98:1-98:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "295",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "292",
                     "s" : [ {
                        "value" : [ "ConceptMapEquivalence" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "294",
                     "s" : [ {
                        "r" : "294",
                        "s" : [ {
                           "r" : "293",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "294",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "294",
               "locator" : "98:56-98:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "293",
                  "locator" : "98:56-98:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "292",
                  "locator" : "98:32-98:52",
                  "name" : "{http://hl7.org/fhir}ConceptMapEquivalence",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "299",
            "locator" : "99:1-99:72",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "299",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "296",
                     "s" : [ {
                        "value" : [ "ConceptMapGroupUnmappedMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "298",
                     "s" : [ {
                        "r" : "298",
                        "s" : [ {
                           "r" : "297",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "298",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "298",
               "locator" : "99:62-99:72",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "297",
                  "locator" : "99:62-99:66",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "296",
                  "locator" : "99:32-99:58",
                  "name" : "{http://hl7.org/fhir}ConceptMapGroupUnmappedMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "303",
            "locator" : "100:1-100:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "303",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "300",
                     "s" : [ {
                        "value" : [ "ConditionalDeleteStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "302",
                     "s" : [ {
                        "r" : "302",
                        "s" : [ {
                           "r" : "301",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "302",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "302",
               "locator" : "100:58-100:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "301",
                  "locator" : "100:58-100:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "300",
                  "locator" : "100:32-100:54",
                  "name" : "{http://hl7.org/fhir}ConditionalDeleteStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "307",
            "locator" : "101:1-101:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "307",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "304",
                     "s" : [ {
                        "value" : [ "ConditionalReadStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "306",
                     "s" : [ {
                        "r" : "306",
                        "s" : [ {
                           "r" : "305",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "306",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "306",
               "locator" : "101:56-101:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "305",
                  "locator" : "101:56-101:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "304",
                  "locator" : "101:32-101:52",
                  "name" : "{http://hl7.org/fhir}ConditionalReadStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "311",
            "locator" : "102:1-102:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "311",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "308",
                     "s" : [ {
                        "value" : [ "ConsentDataMeaning" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "310",
                     "s" : [ {
                        "r" : "310",
                        "s" : [ {
                           "r" : "309",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "310",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "310",
               "locator" : "102:53-102:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "309",
                  "locator" : "102:53-102:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "308",
                  "locator" : "102:32-102:49",
                  "name" : "{http://hl7.org/fhir}ConsentDataMeaning",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "315",
            "locator" : "103:1-103:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "315",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "312",
                     "s" : [ {
                        "value" : [ "ConsentProvisionType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "314",
                     "s" : [ {
                        "r" : "314",
                        "s" : [ {
                           "r" : "313",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "314",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "314",
               "locator" : "103:55-103:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "313",
                  "locator" : "103:55-103:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "312",
                  "locator" : "103:32-103:51",
                  "name" : "{http://hl7.org/fhir}ConsentProvisionType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "319",
            "locator" : "104:1-104:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "319",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "316",
                     "s" : [ {
                        "value" : [ "ConsentState" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "318",
                     "s" : [ {
                        "r" : "318",
                        "s" : [ {
                           "r" : "317",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "318",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "318",
               "locator" : "104:47-104:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "317",
                  "locator" : "104:47-104:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "316",
                  "locator" : "104:32-104:43",
                  "name" : "{http://hl7.org/fhir}ConsentState",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "323",
            "locator" : "105:1-105:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "323",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "320",
                     "s" : [ {
                        "value" : [ "ConstraintSeverity" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "322",
                     "s" : [ {
                        "r" : "322",
                        "s" : [ {
                           "r" : "321",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "322",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "322",
               "locator" : "105:53-105:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "321",
                  "locator" : "105:53-105:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "320",
                  "locator" : "105:32-105:49",
                  "name" : "{http://hl7.org/fhir}ConstraintSeverity",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "327",
            "locator" : "106:1-106:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "327",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "324",
                     "s" : [ {
                        "value" : [ "ContactPointSystem" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "326",
                     "s" : [ {
                        "r" : "326",
                        "s" : [ {
                           "r" : "325",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "326",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "326",
               "locator" : "106:53-106:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "325",
                  "locator" : "106:53-106:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "324",
                  "locator" : "106:32-106:49",
                  "name" : "{http://hl7.org/fhir}ContactPointSystem",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "331",
            "locator" : "107:1-107:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "331",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "328",
                     "s" : [ {
                        "value" : [ "ContactPointUse" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "330",
                     "s" : [ {
                        "r" : "330",
                        "s" : [ {
                           "r" : "329",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "330",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "330",
               "locator" : "107:50-107:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "329",
                  "locator" : "107:50-107:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "328",
                  "locator" : "107:32-107:46",
                  "name" : "{http://hl7.org/fhir}ContactPointUse",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "335",
            "locator" : "108:1-108:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "335",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "332",
                     "s" : [ {
                        "value" : [ "ContractPublicationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "334",
                     "s" : [ {
                        "r" : "334",
                        "s" : [ {
                           "r" : "333",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "334",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "334",
               "locator" : "108:60-108:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "333",
                  "locator" : "108:60-108:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "332",
                  "locator" : "108:32-108:56",
                  "name" : "{http://hl7.org/fhir}ContractPublicationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "339",
            "locator" : "109:1-109:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "339",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "336",
                     "s" : [ {
                        "value" : [ "ContractStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "338",
                     "s" : [ {
                        "r" : "338",
                        "s" : [ {
                           "r" : "337",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "338",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "338",
               "locator" : "109:49-109:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "337",
                  "locator" : "109:49-109:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "336",
                  "locator" : "109:32-109:45",
                  "name" : "{http://hl7.org/fhir}ContractStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "343",
            "locator" : "110:1-110:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "343",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "340",
                     "s" : [ {
                        "value" : [ "ContributorType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "342",
                     "s" : [ {
                        "r" : "342",
                        "s" : [ {
                           "r" : "341",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "342",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "342",
               "locator" : "110:50-110:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "341",
                  "locator" : "110:50-110:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "340",
                  "locator" : "110:32-110:46",
                  "name" : "{http://hl7.org/fhir}ContributorType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "347",
            "locator" : "111:1-111:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "347",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "344",
                     "s" : [ {
                        "value" : [ "CoverageStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "346",
                     "s" : [ {
                        "r" : "346",
                        "s" : [ {
                           "r" : "345",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "346",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "346",
               "locator" : "111:49-111:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "345",
                  "locator" : "111:49-111:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "344",
                  "locator" : "111:32-111:45",
                  "name" : "{http://hl7.org/fhir}CoverageStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "351",
            "locator" : "112:1-112:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "351",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "348",
                     "s" : [ {
                        "value" : [ "CurrencyCode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "350",
                     "s" : [ {
                        "r" : "350",
                        "s" : [ {
                           "r" : "349",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "350",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "350",
               "locator" : "112:47-112:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "349",
                  "locator" : "112:47-112:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "348",
                  "locator" : "112:32-112:43",
                  "name" : "{http://hl7.org/fhir}CurrencyCode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "355",
            "locator" : "113:1-113:54",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "355",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "352",
                     "s" : [ {
                        "value" : [ "DayOfWeek" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "354",
                     "s" : [ {
                        "r" : "354",
                        "s" : [ {
                           "r" : "353",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "354",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "354",
               "locator" : "113:44-113:54",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "353",
                  "locator" : "113:44-113:48",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "352",
                  "locator" : "113:32-113:40",
                  "name" : "{http://hl7.org/fhir}DayOfWeek",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "359",
            "locator" : "114:1-114:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "359",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "356",
                     "s" : [ {
                        "value" : [ "DaysOfWeek" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "358",
                     "s" : [ {
                        "r" : "358",
                        "s" : [ {
                           "r" : "357",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "358",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "358",
               "locator" : "114:45-114:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "357",
                  "locator" : "114:45-114:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "356",
                  "locator" : "114:32-114:41",
                  "name" : "{http://hl7.org/fhir}DaysOfWeek",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "363",
            "locator" : "115:1-115:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "363",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "360",
                     "s" : [ {
                        "value" : [ "DetectedIssueSeverity" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "362",
                     "s" : [ {
                        "r" : "362",
                        "s" : [ {
                           "r" : "361",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "362",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "362",
               "locator" : "115:56-115:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "361",
                  "locator" : "115:56-115:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "360",
                  "locator" : "115:32-115:52",
                  "name" : "{http://hl7.org/fhir}DetectedIssueSeverity",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "367",
            "locator" : "116:1-116:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "367",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "364",
                     "s" : [ {
                        "value" : [ "DetectedIssueStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "366",
                     "s" : [ {
                        "r" : "366",
                        "s" : [ {
                           "r" : "365",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "366",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "366",
               "locator" : "116:54-116:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "365",
                  "locator" : "116:54-116:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "364",
                  "locator" : "116:32-116:50",
                  "name" : "{http://hl7.org/fhir}DetectedIssueStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "371",
            "locator" : "117:1-117:73",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "371",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "368",
                     "s" : [ {
                        "value" : [ "DeviceMetricCalibrationState" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "370",
                     "s" : [ {
                        "r" : "370",
                        "s" : [ {
                           "r" : "369",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "370",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "370",
               "locator" : "117:63-117:73",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "369",
                  "locator" : "117:63-117:67",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "368",
                  "locator" : "117:32-117:59",
                  "name" : "{http://hl7.org/fhir}DeviceMetricCalibrationState",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "375",
            "locator" : "118:1-118:72",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "375",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "372",
                     "s" : [ {
                        "value" : [ "DeviceMetricCalibrationType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "374",
                     "s" : [ {
                        "r" : "374",
                        "s" : [ {
                           "r" : "373",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "374",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "374",
               "locator" : "118:62-118:72",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "373",
                  "locator" : "118:62-118:66",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "372",
                  "locator" : "118:32-118:58",
                  "name" : "{http://hl7.org/fhir}DeviceMetricCalibrationType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "379",
            "locator" : "119:1-119:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "379",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "376",
                     "s" : [ {
                        "value" : [ "DeviceMetricCategory" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "378",
                     "s" : [ {
                        "r" : "378",
                        "s" : [ {
                           "r" : "377",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "378",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "378",
               "locator" : "119:55-119:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "377",
                  "locator" : "119:55-119:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "376",
                  "locator" : "119:32-119:51",
                  "name" : "{http://hl7.org/fhir}DeviceMetricCategory",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "383",
            "locator" : "120:1-120:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "383",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "380",
                     "s" : [ {
                        "value" : [ "DeviceMetricColor" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "382",
                     "s" : [ {
                        "r" : "382",
                        "s" : [ {
                           "r" : "381",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "382",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "382",
               "locator" : "120:52-120:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "381",
                  "locator" : "120:52-120:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "380",
                  "locator" : "120:32-120:48",
                  "name" : "{http://hl7.org/fhir}DeviceMetricColor",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "387",
            "locator" : "121:1-121:74",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "387",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "384",
                     "s" : [ {
                        "value" : [ "DeviceMetricOperationalStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "386",
                     "s" : [ {
                        "r" : "386",
                        "s" : [ {
                           "r" : "385",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "386",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "386",
               "locator" : "121:64-121:74",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "385",
                  "locator" : "121:64-121:68",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "384",
                  "locator" : "121:32-121:60",
                  "name" : "{http://hl7.org/fhir}DeviceMetricOperationalStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "391",
            "locator" : "122:1-122:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "391",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "388",
                     "s" : [ {
                        "value" : [ "DeviceNameType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "390",
                     "s" : [ {
                        "r" : "390",
                        "s" : [ {
                           "r" : "389",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "390",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "390",
               "locator" : "122:49-122:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "389",
                  "locator" : "122:49-122:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "388",
                  "locator" : "122:32-122:45",
                  "name" : "{http://hl7.org/fhir}DeviceNameType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "395",
            "locator" : "123:1-123:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "395",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "392",
                     "s" : [ {
                        "value" : [ "DeviceRequestStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "394",
                     "s" : [ {
                        "r" : "394",
                        "s" : [ {
                           "r" : "393",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "394",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "394",
               "locator" : "123:54-123:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "393",
                  "locator" : "123:54-123:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "392",
                  "locator" : "123:32-123:50",
                  "name" : "{http://hl7.org/fhir}DeviceRequestStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "399",
            "locator" : "124:1-124:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "399",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "396",
                     "s" : [ {
                        "value" : [ "DeviceUseStatementStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "398",
                     "s" : [ {
                        "r" : "398",
                        "s" : [ {
                           "r" : "397",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "398",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "398",
               "locator" : "124:59-124:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "397",
                  "locator" : "124:59-124:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "396",
                  "locator" : "124:32-124:55",
                  "name" : "{http://hl7.org/fhir}DeviceUseStatementStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "403",
            "locator" : "125:1-125:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "403",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "400",
                     "s" : [ {
                        "value" : [ "DiagnosticReportStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "402",
                     "s" : [ {
                        "r" : "402",
                        "s" : [ {
                           "r" : "401",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "402",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "402",
               "locator" : "125:57-125:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "401",
                  "locator" : "125:57-125:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "400",
                  "locator" : "125:32-125:53",
                  "name" : "{http://hl7.org/fhir}DiagnosticReportStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "407",
            "locator" : "126:1-126:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "407",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "404",
                     "s" : [ {
                        "value" : [ "DiscriminatorType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "406",
                     "s" : [ {
                        "r" : "406",
                        "s" : [ {
                           "r" : "405",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "406",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "406",
               "locator" : "126:52-126:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "405",
                  "locator" : "126:52-126:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "404",
                  "locator" : "126:32-126:48",
                  "name" : "{http://hl7.org/fhir}DiscriminatorType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "411",
            "locator" : "127:1-127:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "411",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "408",
                     "s" : [ {
                        "value" : [ "DocumentConfidentiality" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "410",
                     "s" : [ {
                        "r" : "410",
                        "s" : [ {
                           "r" : "409",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "410",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "410",
               "locator" : "127:58-127:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "409",
                  "locator" : "127:58-127:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "408",
                  "locator" : "127:32-127:54",
                  "name" : "{http://hl7.org/fhir}DocumentConfidentiality",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "415",
            "locator" : "128:1-128:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "415",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "412",
                     "s" : [ {
                        "value" : [ "DocumentMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "414",
                     "s" : [ {
                        "r" : "414",
                        "s" : [ {
                           "r" : "413",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "414",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "414",
               "locator" : "128:47-128:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "413",
                  "locator" : "128:47-128:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "412",
                  "locator" : "128:32-128:43",
                  "name" : "{http://hl7.org/fhir}DocumentMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "419",
            "locator" : "129:1-129:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "419",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "416",
                     "s" : [ {
                        "value" : [ "DocumentReferenceStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "418",
                     "s" : [ {
                        "r" : "418",
                        "s" : [ {
                           "r" : "417",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "418",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "418",
               "locator" : "129:58-129:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "417",
                  "locator" : "129:58-129:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "416",
                  "locator" : "129:32-129:54",
                  "name" : "{http://hl7.org/fhir}DocumentReferenceStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "423",
            "locator" : "130:1-130:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "423",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "420",
                     "s" : [ {
                        "value" : [ "DocumentRelationshipType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "422",
                     "s" : [ {
                        "r" : "422",
                        "s" : [ {
                           "r" : "421",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "422",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "422",
               "locator" : "130:59-130:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "421",
                  "locator" : "130:59-130:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "420",
                  "locator" : "130:32-130:55",
                  "name" : "{http://hl7.org/fhir}DocumentRelationshipType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "427",
            "locator" : "131:1-131:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "427",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "424",
                     "s" : [ {
                        "value" : [ "EligibilityRequestPurpose" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "426",
                     "s" : [ {
                        "r" : "426",
                        "s" : [ {
                           "r" : "425",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "426",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "426",
               "locator" : "131:60-131:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "425",
                  "locator" : "131:60-131:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "424",
                  "locator" : "131:32-131:56",
                  "name" : "{http://hl7.org/fhir}EligibilityRequestPurpose",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "431",
            "locator" : "132:1-132:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "431",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "428",
                     "s" : [ {
                        "value" : [ "EligibilityRequestStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "430",
                     "s" : [ {
                        "r" : "430",
                        "s" : [ {
                           "r" : "429",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "430",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "430",
               "locator" : "132:59-132:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "429",
                  "locator" : "132:59-132:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "428",
                  "locator" : "132:32-132:55",
                  "name" : "{http://hl7.org/fhir}EligibilityRequestStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "435",
            "locator" : "133:1-133:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "435",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "432",
                     "s" : [ {
                        "value" : [ "EligibilityResponsePurpose" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "434",
                     "s" : [ {
                        "r" : "434",
                        "s" : [ {
                           "r" : "433",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "434",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "434",
               "locator" : "133:61-133:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "433",
                  "locator" : "133:61-133:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "432",
                  "locator" : "133:32-133:57",
                  "name" : "{http://hl7.org/fhir}EligibilityResponsePurpose",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "439",
            "locator" : "134:1-134:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "439",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "436",
                     "s" : [ {
                        "value" : [ "EligibilityResponseStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "438",
                     "s" : [ {
                        "r" : "438",
                        "s" : [ {
                           "r" : "437",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "438",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "438",
               "locator" : "134:60-134:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "437",
                  "locator" : "134:60-134:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "436",
                  "locator" : "134:32-134:56",
                  "name" : "{http://hl7.org/fhir}EligibilityResponseStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "443",
            "locator" : "135:1-135:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "443",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "440",
                     "s" : [ {
                        "value" : [ "EnableWhenBehavior" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "442",
                     "s" : [ {
                        "r" : "442",
                        "s" : [ {
                           "r" : "441",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "442",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "442",
               "locator" : "135:53-135:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "441",
                  "locator" : "135:53-135:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "440",
                  "locator" : "135:32-135:49",
                  "name" : "{http://hl7.org/fhir}EnableWhenBehavior",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "447",
            "locator" : "136:1-136:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "447",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "444",
                     "s" : [ {
                        "value" : [ "EncounterLocationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "446",
                     "s" : [ {
                        "r" : "446",
                        "s" : [ {
                           "r" : "445",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "446",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "446",
               "locator" : "136:58-136:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "445",
                  "locator" : "136:58-136:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "444",
                  "locator" : "136:32-136:54",
                  "name" : "{http://hl7.org/fhir}EncounterLocationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "451",
            "locator" : "137:1-137:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "451",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "448",
                     "s" : [ {
                        "value" : [ "EncounterStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "450",
                     "s" : [ {
                        "r" : "450",
                        "s" : [ {
                           "r" : "449",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "450",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "450",
               "locator" : "137:50-137:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "449",
                  "locator" : "137:50-137:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "448",
                  "locator" : "137:32-137:46",
                  "name" : "{http://hl7.org/fhir}EncounterStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "455",
            "locator" : "138:1-138:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "455",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "452",
                     "s" : [ {
                        "value" : [ "EndpointStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "454",
                     "s" : [ {
                        "r" : "454",
                        "s" : [ {
                           "r" : "453",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "454",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "454",
               "locator" : "138:49-138:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "453",
                  "locator" : "138:49-138:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "452",
                  "locator" : "138:32-138:45",
                  "name" : "{http://hl7.org/fhir}EndpointStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "459",
            "locator" : "139:1-139:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "459",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "456",
                     "s" : [ {
                        "value" : [ "EnrollmentRequestStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "458",
                     "s" : [ {
                        "r" : "458",
                        "s" : [ {
                           "r" : "457",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "458",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "458",
               "locator" : "139:58-139:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "457",
                  "locator" : "139:58-139:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "456",
                  "locator" : "139:32-139:54",
                  "name" : "{http://hl7.org/fhir}EnrollmentRequestStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "463",
            "locator" : "140:1-140:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "463",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "460",
                     "s" : [ {
                        "value" : [ "EnrollmentResponseStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "462",
                     "s" : [ {
                        "r" : "462",
                        "s" : [ {
                           "r" : "461",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "462",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "462",
               "locator" : "140:59-140:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "461",
                  "locator" : "140:59-140:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "460",
                  "locator" : "140:32-140:55",
                  "name" : "{http://hl7.org/fhir}EnrollmentResponseStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "467",
            "locator" : "141:1-141:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "467",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "464",
                     "s" : [ {
                        "value" : [ "EpisodeOfCareStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "466",
                     "s" : [ {
                        "r" : "466",
                        "s" : [ {
                           "r" : "465",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "466",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "466",
               "locator" : "141:54-141:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "465",
                  "locator" : "141:54-141:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "464",
                  "locator" : "141:32-141:50",
                  "name" : "{http://hl7.org/fhir}EpisodeOfCareStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "471",
            "locator" : "142:1-142:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "471",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "468",
                     "s" : [ {
                        "value" : [ "EventCapabilityMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "470",
                     "s" : [ {
                        "r" : "470",
                        "s" : [ {
                           "r" : "469",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "470",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "470",
               "locator" : "142:54-142:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "469",
                  "locator" : "142:54-142:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "468",
                  "locator" : "142:32-142:50",
                  "name" : "{http://hl7.org/fhir}EventCapabilityMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "475",
            "locator" : "143:1-143:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "475",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "472",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "474",
                     "s" : [ {
                        "r" : "474",
                        "s" : [ {
                           "r" : "473",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "474",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "474",
               "locator" : "143:46-143:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "473",
                  "locator" : "143:46-143:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "472",
                  "locator" : "143:32-143:42",
                  "name" : "{http://hl7.org/fhir}EventTiming",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "479",
            "locator" : "144:1-144:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "479",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "476",
                     "s" : [ {
                        "value" : [ "EvidenceVariableType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "478",
                     "s" : [ {
                        "r" : "478",
                        "s" : [ {
                           "r" : "477",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "478",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "478",
               "locator" : "144:55-144:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "477",
                  "locator" : "144:55-144:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "476",
                  "locator" : "144:32-144:51",
                  "name" : "{http://hl7.org/fhir}EvidenceVariableType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "483",
            "locator" : "145:1-145:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "483",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "480",
                     "s" : [ {
                        "value" : [ "ExampleScenarioActorType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "482",
                     "s" : [ {
                        "r" : "482",
                        "s" : [ {
                           "r" : "481",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "482",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "482",
               "locator" : "145:59-145:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "481",
                  "locator" : "145:59-145:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "480",
                  "locator" : "145:32-145:55",
                  "name" : "{http://hl7.org/fhir}ExampleScenarioActorType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "487",
            "locator" : "146:1-146:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "487",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "484",
                     "s" : [ {
                        "value" : [ "ExplanationOfBenefitStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "486",
                     "s" : [ {
                        "r" : "486",
                        "s" : [ {
                           "r" : "485",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "486",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "486",
               "locator" : "146:61-146:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "485",
                  "locator" : "146:61-146:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "484",
                  "locator" : "146:32-146:57",
                  "name" : "{http://hl7.org/fhir}ExplanationOfBenefitStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "491",
            "locator" : "147:1-147:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "491",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "488",
                     "s" : [ {
                        "value" : [ "ExposureState" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "490",
                     "s" : [ {
                        "r" : "490",
                        "s" : [ {
                           "r" : "489",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "490",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "490",
               "locator" : "147:48-147:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "489",
                  "locator" : "147:48-147:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "488",
                  "locator" : "147:32-147:44",
                  "name" : "{http://hl7.org/fhir}ExposureState",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "495",
            "locator" : "148:1-148:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "495",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "492",
                     "s" : [ {
                        "value" : [ "ExtensionContextType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "494",
                     "s" : [ {
                        "r" : "494",
                        "s" : [ {
                           "r" : "493",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "494",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "494",
               "locator" : "148:55-148:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "493",
                  "locator" : "148:55-148:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "492",
                  "locator" : "148:32-148:51",
                  "name" : "{http://hl7.org/fhir}ExtensionContextType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "499",
            "locator" : "149:1-149:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "499",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "496",
                     "s" : [ {
                        "value" : [ "FHIRAllTypes" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "498",
                     "s" : [ {
                        "r" : "498",
                        "s" : [ {
                           "r" : "497",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "498",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "498",
               "locator" : "149:47-149:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "497",
                  "locator" : "149:47-149:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "496",
                  "locator" : "149:32-149:43",
                  "name" : "{http://hl7.org/fhir}FHIRAllTypes",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "503",
            "locator" : "150:1-150:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "503",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "500",
                     "s" : [ {
                        "value" : [ "FHIRDefinedType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "502",
                     "s" : [ {
                        "r" : "502",
                        "s" : [ {
                           "r" : "501",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "502",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "502",
               "locator" : "150:50-150:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "501",
                  "locator" : "150:50-150:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "500",
                  "locator" : "150:32-150:46",
                  "name" : "{http://hl7.org/fhir}FHIRDefinedType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "507",
            "locator" : "151:1-151:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "507",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "504",
                     "s" : [ {
                        "value" : [ "FHIRDeviceStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "506",
                     "s" : [ {
                        "r" : "506",
                        "s" : [ {
                           "r" : "505",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "506",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "506",
               "locator" : "151:51-151:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "505",
                  "locator" : "151:51-151:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "504",
                  "locator" : "151:32-151:47",
                  "name" : "{http://hl7.org/fhir}FHIRDeviceStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "511",
            "locator" : "152:1-152:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "511",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "508",
                     "s" : [ {
                        "value" : [ "FHIRResourceType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "510",
                     "s" : [ {
                        "r" : "510",
                        "s" : [ {
                           "r" : "509",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "510",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "510",
               "locator" : "152:51-152:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "509",
                  "locator" : "152:51-152:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "508",
                  "locator" : "152:32-152:47",
                  "name" : "{http://hl7.org/fhir}FHIRResourceType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "515",
            "locator" : "153:1-153:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "515",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "512",
                     "s" : [ {
                        "value" : [ "FHIRSubstanceStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "514",
                     "s" : [ {
                        "r" : "514",
                        "s" : [ {
                           "r" : "513",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "514",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "514",
               "locator" : "153:54-153:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "513",
                  "locator" : "153:54-153:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "512",
                  "locator" : "153:32-153:50",
                  "name" : "{http://hl7.org/fhir}FHIRSubstanceStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "519",
            "locator" : "154:1-154:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "519",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "516",
                     "s" : [ {
                        "value" : [ "FHIRVersion" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "518",
                     "s" : [ {
                        "r" : "518",
                        "s" : [ {
                           "r" : "517",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "518",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "518",
               "locator" : "154:46-154:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "517",
                  "locator" : "154:46-154:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "516",
                  "locator" : "154:32-154:42",
                  "name" : "{http://hl7.org/fhir}FHIRVersion",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "523",
            "locator" : "155:1-155:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "523",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "520",
                     "s" : [ {
                        "value" : [ "FamilyHistoryStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "522",
                     "s" : [ {
                        "r" : "522",
                        "s" : [ {
                           "r" : "521",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "522",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "522",
               "locator" : "155:54-155:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "521",
                  "locator" : "155:54-155:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "520",
                  "locator" : "155:32-155:50",
                  "name" : "{http://hl7.org/fhir}FamilyHistoryStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "527",
            "locator" : "156:1-156:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "527",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "524",
                     "s" : [ {
                        "value" : [ "FilterOperator" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "526",
                     "s" : [ {
                        "r" : "526",
                        "s" : [ {
                           "r" : "525",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "526",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "526",
               "locator" : "156:49-156:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "525",
                  "locator" : "156:49-156:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "524",
                  "locator" : "156:32-156:45",
                  "name" : "{http://hl7.org/fhir}FilterOperator",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "531",
            "locator" : "157:1-157:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "531",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "528",
                     "s" : [ {
                        "value" : [ "FlagStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "530",
                     "s" : [ {
                        "r" : "530",
                        "s" : [ {
                           "r" : "529",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "530",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "530",
               "locator" : "157:45-157:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "529",
                  "locator" : "157:45-157:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "528",
                  "locator" : "157:32-157:41",
                  "name" : "{http://hl7.org/fhir}FlagStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "535",
            "locator" : "158:1-158:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "535",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "532",
                     "s" : [ {
                        "value" : [ "GoalLifecycleStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "534",
                     "s" : [ {
                        "r" : "534",
                        "s" : [ {
                           "r" : "533",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "534",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "534",
               "locator" : "158:54-158:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "533",
                  "locator" : "158:54-158:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "532",
                  "locator" : "158:32-158:50",
                  "name" : "{http://hl7.org/fhir}GoalLifecycleStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "539",
            "locator" : "159:1-159:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "539",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "536",
                     "s" : [ {
                        "value" : [ "GraphCompartmentRule" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "538",
                     "s" : [ {
                        "r" : "538",
                        "s" : [ {
                           "r" : "537",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "538",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "538",
               "locator" : "159:55-159:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "537",
                  "locator" : "159:55-159:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "536",
                  "locator" : "159:32-159:51",
                  "name" : "{http://hl7.org/fhir}GraphCompartmentRule",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "543",
            "locator" : "160:1-160:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "543",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "540",
                     "s" : [ {
                        "value" : [ "GraphCompartmentUse" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "542",
                     "s" : [ {
                        "r" : "542",
                        "s" : [ {
                           "r" : "541",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "542",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "542",
               "locator" : "160:54-160:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "541",
                  "locator" : "160:54-160:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "540",
                  "locator" : "160:32-160:50",
                  "name" : "{http://hl7.org/fhir}GraphCompartmentUse",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "547",
            "locator" : "161:1-161:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "547",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "544",
                     "s" : [ {
                        "value" : [ "GroupMeasure" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "546",
                     "s" : [ {
                        "r" : "546",
                        "s" : [ {
                           "r" : "545",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "546",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "546",
               "locator" : "161:47-161:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "545",
                  "locator" : "161:47-161:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "544",
                  "locator" : "161:32-161:43",
                  "name" : "{http://hl7.org/fhir}GroupMeasure",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "551",
            "locator" : "162:1-162:54",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "551",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "548",
                     "s" : [ {
                        "value" : [ "GroupType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "550",
                     "s" : [ {
                        "r" : "550",
                        "s" : [ {
                           "r" : "549",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "550",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "550",
               "locator" : "162:44-162:54",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "549",
                  "locator" : "162:44-162:48",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "548",
                  "locator" : "162:32-162:40",
                  "name" : "{http://hl7.org/fhir}GroupType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "555",
            "locator" : "163:1-163:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "555",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "552",
                     "s" : [ {
                        "value" : [ "GuidanceResponseStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "554",
                     "s" : [ {
                        "r" : "554",
                        "s" : [ {
                           "r" : "553",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "554",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "554",
               "locator" : "163:57-163:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "553",
                  "locator" : "163:57-163:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "552",
                  "locator" : "163:32-163:53",
                  "name" : "{http://hl7.org/fhir}GuidanceResponseStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "559",
            "locator" : "164:1-164:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "559",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "556",
                     "s" : [ {
                        "value" : [ "GuidePageGeneration" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "558",
                     "s" : [ {
                        "r" : "558",
                        "s" : [ {
                           "r" : "557",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "558",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "558",
               "locator" : "164:54-164:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "557",
                  "locator" : "164:54-164:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "556",
                  "locator" : "164:32-164:50",
                  "name" : "{http://hl7.org/fhir}GuidePageGeneration",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "563",
            "locator" : "165:1-165:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "563",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "560",
                     "s" : [ {
                        "value" : [ "GuideParameterCode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "562",
                     "s" : [ {
                        "r" : "562",
                        "s" : [ {
                           "r" : "561",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "562",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "562",
               "locator" : "165:53-165:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "561",
                  "locator" : "165:53-165:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "560",
                  "locator" : "165:32-165:49",
                  "name" : "{http://hl7.org/fhir}GuideParameterCode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "567",
            "locator" : "166:1-166:53",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "567",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "564",
                     "s" : [ {
                        "value" : [ "HTTPVerb" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "566",
                     "s" : [ {
                        "r" : "566",
                        "s" : [ {
                           "r" : "565",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "566",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "566",
               "locator" : "166:43-166:53",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "565",
                  "locator" : "166:43-166:47",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "564",
                  "locator" : "166:32-166:39",
                  "name" : "{http://hl7.org/fhir}HTTPVerb",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "571",
            "locator" : "167:1-167:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "571",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "568",
                     "s" : [ {
                        "value" : [ "IdentifierUse" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "570",
                     "s" : [ {
                        "r" : "570",
                        "s" : [ {
                           "r" : "569",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "570",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "570",
               "locator" : "167:48-167:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "569",
                  "locator" : "167:48-167:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "568",
                  "locator" : "167:32-167:44",
                  "name" : "{http://hl7.org/fhir}IdentifierUse",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "575",
            "locator" : "168:1-168:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "575",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "572",
                     "s" : [ {
                        "value" : [ "IdentityAssuranceLevel" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "574",
                     "s" : [ {
                        "r" : "574",
                        "s" : [ {
                           "r" : "573",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "574",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "574",
               "locator" : "168:57-168:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "573",
                  "locator" : "168:57-168:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "572",
                  "locator" : "168:32-168:53",
                  "name" : "{http://hl7.org/fhir}IdentityAssuranceLevel",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "579",
            "locator" : "169:1-169:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "579",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "576",
                     "s" : [ {
                        "value" : [ "ImagingStudyStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "578",
                     "s" : [ {
                        "r" : "578",
                        "s" : [ {
                           "r" : "577",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "578",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "578",
               "locator" : "169:53-169:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "577",
                  "locator" : "169:53-169:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "576",
                  "locator" : "169:32-169:49",
                  "name" : "{http://hl7.org/fhir}ImagingStudyStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "583",
            "locator" : "170:1-170:73",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "583",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "580",
                     "s" : [ {
                        "value" : [ "ImmunizationEvaluationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "582",
                     "s" : [ {
                        "r" : "582",
                        "s" : [ {
                           "r" : "581",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "582",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "582",
               "locator" : "170:63-170:73",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "581",
                  "locator" : "170:63-170:67",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "580",
                  "locator" : "170:32-170:59",
                  "name" : "{http://hl7.org/fhir}ImmunizationEvaluationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "587",
            "locator" : "171:1-171:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "587",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "584",
                     "s" : [ {
                        "value" : [ "ImmunizationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "586",
                     "s" : [ {
                        "r" : "586",
                        "s" : [ {
                           "r" : "585",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "586",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "586",
               "locator" : "171:53-171:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "585",
                  "locator" : "171:53-171:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "584",
                  "locator" : "171:32-171:49",
                  "name" : "{http://hl7.org/fhir}ImmunizationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "591",
            "locator" : "172:1-172:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "591",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "588",
                     "s" : [ {
                        "value" : [ "InvoicePriceComponentType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "590",
                     "s" : [ {
                        "r" : "590",
                        "s" : [ {
                           "r" : "589",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "590",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "590",
               "locator" : "172:60-172:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "589",
                  "locator" : "172:60-172:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "588",
                  "locator" : "172:32-172:56",
                  "name" : "{http://hl7.org/fhir}InvoicePriceComponentType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "595",
            "locator" : "173:1-173:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "595",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "592",
                     "s" : [ {
                        "value" : [ "InvoiceStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "594",
                     "s" : [ {
                        "r" : "594",
                        "s" : [ {
                           "r" : "593",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "594",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "594",
               "locator" : "173:48-173:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "593",
                  "locator" : "173:48-173:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "592",
                  "locator" : "173:32-173:44",
                  "name" : "{http://hl7.org/fhir}InvoiceStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "599",
            "locator" : "174:1-174:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "599",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "596",
                     "s" : [ {
                        "value" : [ "IssueSeverity" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "598",
                     "s" : [ {
                        "r" : "598",
                        "s" : [ {
                           "r" : "597",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "598",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "598",
               "locator" : "174:48-174:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "597",
                  "locator" : "174:48-174:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "596",
                  "locator" : "174:32-174:44",
                  "name" : "{http://hl7.org/fhir}IssueSeverity",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "603",
            "locator" : "175:1-175:54",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "603",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "600",
                     "s" : [ {
                        "value" : [ "IssueType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "602",
                     "s" : [ {
                        "r" : "602",
                        "s" : [ {
                           "r" : "601",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "602",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "602",
               "locator" : "175:44-175:54",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "601",
                  "locator" : "175:44-175:48",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "600",
                  "locator" : "175:32-175:40",
                  "name" : "{http://hl7.org/fhir}IssueType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "607",
            "locator" : "176:1-176:53",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "607",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "604",
                     "s" : [ {
                        "value" : [ "LinkType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "606",
                     "s" : [ {
                        "r" : "606",
                        "s" : [ {
                           "r" : "605",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "606",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "606",
               "locator" : "176:43-176:53",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "605",
                  "locator" : "176:43-176:47",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "604",
                  "locator" : "176:32-176:39",
                  "name" : "{http://hl7.org/fhir}LinkType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "611",
            "locator" : "177:1-177:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "611",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "608",
                     "s" : [ {
                        "value" : [ "LinkageType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "610",
                     "s" : [ {
                        "r" : "610",
                        "s" : [ {
                           "r" : "609",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "610",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "610",
               "locator" : "177:46-177:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "609",
                  "locator" : "177:46-177:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "608",
                  "locator" : "177:32-177:42",
                  "name" : "{http://hl7.org/fhir}LinkageType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "615",
            "locator" : "178:1-178:53",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "615",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "612",
                     "s" : [ {
                        "value" : [ "ListMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "614",
                     "s" : [ {
                        "r" : "614",
                        "s" : [ {
                           "r" : "613",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "614",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "614",
               "locator" : "178:43-178:53",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "613",
                  "locator" : "178:43-178:47",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "612",
                  "locator" : "178:32-178:39",
                  "name" : "{http://hl7.org/fhir}ListMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "619",
            "locator" : "179:1-179:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "619",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "616",
                     "s" : [ {
                        "value" : [ "ListStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "618",
                     "s" : [ {
                        "r" : "618",
                        "s" : [ {
                           "r" : "617",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "618",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "618",
               "locator" : "179:45-179:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "617",
                  "locator" : "179:45-179:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "616",
                  "locator" : "179:32-179:41",
                  "name" : "{http://hl7.org/fhir}ListStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "623",
            "locator" : "180:1-180:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "623",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "620",
                     "s" : [ {
                        "value" : [ "LocationMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "622",
                     "s" : [ {
                        "r" : "622",
                        "s" : [ {
                           "r" : "621",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "622",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "622",
               "locator" : "180:47-180:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "621",
                  "locator" : "180:47-180:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "620",
                  "locator" : "180:32-180:43",
                  "name" : "{http://hl7.org/fhir}LocationMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "627",
            "locator" : "181:1-181:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "627",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "624",
                     "s" : [ {
                        "value" : [ "LocationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "626",
                     "s" : [ {
                        "r" : "626",
                        "s" : [ {
                           "r" : "625",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "626",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "626",
               "locator" : "181:49-181:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "625",
                  "locator" : "181:49-181:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "624",
                  "locator" : "181:32-181:45",
                  "name" : "{http://hl7.org/fhir}LocationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "631",
            "locator" : "182:1-182:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "631",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "628",
                     "s" : [ {
                        "value" : [ "MeasureReportStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "630",
                     "s" : [ {
                        "r" : "630",
                        "s" : [ {
                           "r" : "629",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "630",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "630",
               "locator" : "182:54-182:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "629",
                  "locator" : "182:54-182:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "628",
                  "locator" : "182:32-182:50",
                  "name" : "{http://hl7.org/fhir}MeasureReportStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "635",
            "locator" : "183:1-183:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "635",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "632",
                     "s" : [ {
                        "value" : [ "MeasureReportType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "634",
                     "s" : [ {
                        "r" : "634",
                        "s" : [ {
                           "r" : "633",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "634",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "634",
               "locator" : "183:52-183:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "633",
                  "locator" : "183:52-183:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "632",
                  "locator" : "183:32-183:48",
                  "name" : "{http://hl7.org/fhir}MeasureReportType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "639",
            "locator" : "184:1-184:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "639",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "636",
                     "s" : [ {
                        "value" : [ "MediaStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "638",
                     "s" : [ {
                        "r" : "638",
                        "s" : [ {
                           "r" : "637",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "638",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "638",
               "locator" : "184:46-184:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "637",
                  "locator" : "184:46-184:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "636",
                  "locator" : "184:32-184:42",
                  "name" : "{http://hl7.org/fhir}MediaStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "643",
            "locator" : "185:1-185:75",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "643",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "640",
                     "s" : [ {
                        "value" : [ "MedicationAdministrationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "642",
                     "s" : [ {
                        "r" : "642",
                        "s" : [ {
                           "r" : "641",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "642",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "642",
               "locator" : "185:65-185:75",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "641",
                  "locator" : "185:65-185:69",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "640",
                  "locator" : "185:32-185:61",
                  "name" : "{http://hl7.org/fhir}MedicationAdministrationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "647",
            "locator" : "186:1-186:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "647",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "644",
                     "s" : [ {
                        "value" : [ "MedicationDispenseStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "646",
                     "s" : [ {
                        "r" : "646",
                        "s" : [ {
                           "r" : "645",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "646",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "646",
               "locator" : "186:59-186:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "645",
                  "locator" : "186:59-186:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "644",
                  "locator" : "186:32-186:55",
                  "name" : "{http://hl7.org/fhir}MedicationDispenseStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "651",
            "locator" : "187:1-187:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "651",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "648",
                     "s" : [ {
                        "value" : [ "MedicationKnowledgeStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "650",
                     "s" : [ {
                        "r" : "650",
                        "s" : [ {
                           "r" : "649",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "650",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "650",
               "locator" : "187:60-187:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "649",
                  "locator" : "187:60-187:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "648",
                  "locator" : "187:32-187:56",
                  "name" : "{http://hl7.org/fhir}MedicationKnowledgeStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "655",
            "locator" : "188:1-188:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "655",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "652",
                     "s" : [ {
                        "value" : [ "MedicationRequestIntent" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "654",
                     "s" : [ {
                        "r" : "654",
                        "s" : [ {
                           "r" : "653",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "654",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "654",
               "locator" : "188:58-188:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "653",
                  "locator" : "188:58-188:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "652",
                  "locator" : "188:32-188:54",
                  "name" : "{http://hl7.org/fhir}MedicationRequestIntent",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "659",
            "locator" : "189:1-189:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "659",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "656",
                     "s" : [ {
                        "value" : [ "MedicationRequestPriority" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "658",
                     "s" : [ {
                        "r" : "658",
                        "s" : [ {
                           "r" : "657",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "658",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "658",
               "locator" : "189:60-189:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "657",
                  "locator" : "189:60-189:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "656",
                  "locator" : "189:32-189:56",
                  "name" : "{http://hl7.org/fhir}MedicationRequestPriority",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "663",
            "locator" : "190:1-190:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "663",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "660",
                     "s" : [ {
                        "value" : [ "MedicationRequestStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "662",
                     "s" : [ {
                        "r" : "662",
                        "s" : [ {
                           "r" : "661",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "662",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "662",
               "locator" : "190:58-190:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "661",
                  "locator" : "190:58-190:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "660",
                  "locator" : "190:32-190:54",
                  "name" : "{http://hl7.org/fhir}MedicationRequestStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "667",
            "locator" : "191:1-191:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "667",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "664",
                     "s" : [ {
                        "value" : [ "MedicationStatementStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "666",
                     "s" : [ {
                        "r" : "666",
                        "s" : [ {
                           "r" : "665",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "666",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "666",
               "locator" : "191:60-191:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "665",
                  "locator" : "191:60-191:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "664",
                  "locator" : "191:32-191:56",
                  "name" : "{http://hl7.org/fhir}MedicationStatementStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "671",
            "locator" : "192:1-192:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "671",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "668",
                     "s" : [ {
                        "value" : [ "MedicationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "670",
                     "s" : [ {
                        "r" : "670",
                        "s" : [ {
                           "r" : "669",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "670",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "670",
               "locator" : "192:51-192:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "669",
                  "locator" : "192:51-192:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "668",
                  "locator" : "192:32-192:47",
                  "name" : "{http://hl7.org/fhir}MedicationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "675",
            "locator" : "193:1-193:72",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "675",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "672",
                     "s" : [ {
                        "value" : [ "MessageSignificanceCategory" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "674",
                     "s" : [ {
                        "r" : "674",
                        "s" : [ {
                           "r" : "673",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "674",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "674",
               "locator" : "193:62-193:72",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "673",
                  "locator" : "193:62-193:66",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "672",
                  "locator" : "193:32-193:58",
                  "name" : "{http://hl7.org/fhir}MessageSignificanceCategory",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "679",
            "locator" : "194:1-194:75",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "679",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "676",
                     "s" : [ {
                        "value" : [ "Messageheader_Response_Request" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "678",
                     "s" : [ {
                        "r" : "678",
                        "s" : [ {
                           "r" : "677",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "678",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "678",
               "locator" : "194:65-194:75",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "677",
                  "locator" : "194:65-194:69",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "676",
                  "locator" : "194:32-194:61",
                  "name" : "{http://hl7.org/fhir}Messageheader_Response_Request",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "683",
            "locator" : "195:1-195:53",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "683",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "680",
                     "s" : [ {
                        "value" : [ "MimeType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "682",
                     "s" : [ {
                        "r" : "682",
                        "s" : [ {
                           "r" : "681",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "682",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "682",
               "locator" : "195:43-195:53",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "681",
                  "locator" : "195:43-195:47",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "680",
                  "locator" : "195:32-195:39",
                  "name" : "{http://hl7.org/fhir}MimeType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "687",
            "locator" : "196:1-196:52",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "687",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "684",
                     "s" : [ {
                        "value" : [ "NameUse" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "686",
                     "s" : [ {
                        "r" : "686",
                        "s" : [ {
                           "r" : "685",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "686",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "686",
               "locator" : "196:42-196:52",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "685",
                  "locator" : "196:42-196:46",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "684",
                  "locator" : "196:32-196:38",
                  "name" : "{http://hl7.org/fhir}NameUse",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "691",
            "locator" : "197:1-197:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "691",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "688",
                     "s" : [ {
                        "value" : [ "NamingSystemIdentifierType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "690",
                     "s" : [ {
                        "r" : "690",
                        "s" : [ {
                           "r" : "689",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "690",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "690",
               "locator" : "197:61-197:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "689",
                  "locator" : "197:61-197:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "688",
                  "locator" : "197:32-197:57",
                  "name" : "{http://hl7.org/fhir}NamingSystemIdentifierType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "695",
            "locator" : "198:1-198:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "695",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "692",
                     "s" : [ {
                        "value" : [ "NamingSystemType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "694",
                     "s" : [ {
                        "r" : "694",
                        "s" : [ {
                           "r" : "693",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "694",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "694",
               "locator" : "198:51-198:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "693",
                  "locator" : "198:51-198:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "692",
                  "locator" : "198:32-198:47",
                  "name" : "{http://hl7.org/fhir}NamingSystemType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "699",
            "locator" : "199:1-199:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "699",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "696",
                     "s" : [ {
                        "value" : [ "NarrativeStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "698",
                     "s" : [ {
                        "r" : "698",
                        "s" : [ {
                           "r" : "697",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "698",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "698",
               "locator" : "199:50-199:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "697",
                  "locator" : "199:50-199:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "696",
                  "locator" : "199:32-199:46",
                  "name" : "{http://hl7.org/fhir}NarrativeStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "703",
            "locator" : "200:1-200:53",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "703",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "700",
                     "s" : [ {
                        "value" : [ "NoteType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "702",
                     "s" : [ {
                        "r" : "702",
                        "s" : [ {
                           "r" : "701",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "702",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "702",
               "locator" : "200:43-200:53",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "701",
                  "locator" : "200:43-200:47",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "700",
                  "locator" : "200:32-200:39",
                  "name" : "{http://hl7.org/fhir}NoteType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "707",
            "locator" : "201:1-201:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "707",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "704",
                     "s" : [ {
                        "value" : [ "NutritiionOrderIntent" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "706",
                     "s" : [ {
                        "r" : "706",
                        "s" : [ {
                           "r" : "705",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "706",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "706",
               "locator" : "201:56-201:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "705",
                  "locator" : "201:56-201:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "704",
                  "locator" : "201:32-201:52",
                  "name" : "{http://hl7.org/fhir}NutritiionOrderIntent",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "711",
            "locator" : "202:1-202:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "711",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "708",
                     "s" : [ {
                        "value" : [ "NutritionOrderStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "710",
                     "s" : [ {
                        "r" : "710",
                        "s" : [ {
                           "r" : "709",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "710",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "710",
               "locator" : "202:55-202:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "709",
                  "locator" : "202:55-202:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "708",
                  "locator" : "202:32-202:51",
                  "name" : "{http://hl7.org/fhir}NutritionOrderStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "715",
            "locator" : "203:1-203:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "715",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "712",
                     "s" : [ {
                        "value" : [ "ObservationDataType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "714",
                     "s" : [ {
                        "r" : "714",
                        "s" : [ {
                           "r" : "713",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "714",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "714",
               "locator" : "203:54-203:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "713",
                  "locator" : "203:54-203:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "712",
                  "locator" : "203:32-203:50",
                  "name" : "{http://hl7.org/fhir}ObservationDataType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "719",
            "locator" : "204:1-204:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "719",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "716",
                     "s" : [ {
                        "value" : [ "ObservationRangeCategory" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "718",
                     "s" : [ {
                        "r" : "718",
                        "s" : [ {
                           "r" : "717",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "718",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "718",
               "locator" : "204:59-204:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "717",
                  "locator" : "204:59-204:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "716",
                  "locator" : "204:32-204:55",
                  "name" : "{http://hl7.org/fhir}ObservationRangeCategory",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "723",
            "locator" : "205:1-205:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "723",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "720",
                     "s" : [ {
                        "value" : [ "ObservationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "722",
                     "s" : [ {
                        "r" : "722",
                        "s" : [ {
                           "r" : "721",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "722",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "722",
               "locator" : "205:52-205:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "721",
                  "locator" : "205:52-205:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "720",
                  "locator" : "205:32-205:48",
                  "name" : "{http://hl7.org/fhir}ObservationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "727",
            "locator" : "206:1-206:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "727",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "724",
                     "s" : [ {
                        "value" : [ "OperationKind" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "726",
                     "s" : [ {
                        "r" : "726",
                        "s" : [ {
                           "r" : "725",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "726",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "726",
               "locator" : "206:48-206:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "725",
                  "locator" : "206:48-206:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "724",
                  "locator" : "206:32-206:44",
                  "name" : "{http://hl7.org/fhir}OperationKind",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "731",
            "locator" : "207:1-207:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "731",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "728",
                     "s" : [ {
                        "value" : [ "OperationParameterUse" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "730",
                     "s" : [ {
                        "r" : "730",
                        "s" : [ {
                           "r" : "729",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "730",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "730",
               "locator" : "207:56-207:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "729",
                  "locator" : "207:56-207:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "728",
                  "locator" : "207:32-207:52",
                  "name" : "{http://hl7.org/fhir}OperationParameterUse",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "735",
            "locator" : "208:1-208:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "735",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "732",
                     "s" : [ {
                        "value" : [ "OrientationType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "734",
                     "s" : [ {
                        "r" : "734",
                        "s" : [ {
                           "r" : "733",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "734",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "734",
               "locator" : "208:50-208:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "733",
                  "locator" : "208:50-208:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "732",
                  "locator" : "208:32-208:46",
                  "name" : "{http://hl7.org/fhir}OrientationType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "739",
            "locator" : "209:1-209:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "739",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "736",
                     "s" : [ {
                        "value" : [ "ParameterUse" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "738",
                     "s" : [ {
                        "r" : "738",
                        "s" : [ {
                           "r" : "737",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "738",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "738",
               "locator" : "209:47-209:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "737",
                  "locator" : "209:47-209:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "736",
                  "locator" : "209:32-209:43",
                  "name" : "{http://hl7.org/fhir}ParameterUse",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "743",
            "locator" : "210:1-210:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "743",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "740",
                     "s" : [ {
                        "value" : [ "ParticipantRequired" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "742",
                     "s" : [ {
                        "r" : "742",
                        "s" : [ {
                           "r" : "741",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "742",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "742",
               "locator" : "210:54-210:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "741",
                  "locator" : "210:54-210:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "740",
                  "locator" : "210:32-210:50",
                  "name" : "{http://hl7.org/fhir}ParticipantRequired",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "747",
            "locator" : "211:1-211:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "747",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "744",
                     "s" : [ {
                        "value" : [ "ParticipantStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "746",
                     "s" : [ {
                        "r" : "746",
                        "s" : [ {
                           "r" : "745",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "746",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "746",
               "locator" : "211:52-211:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "745",
                  "locator" : "211:52-211:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "744",
                  "locator" : "211:32-211:48",
                  "name" : "{http://hl7.org/fhir}ParticipantStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "751",
            "locator" : "212:1-212:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "751",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "748",
                     "s" : [ {
                        "value" : [ "ParticipationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "750",
                     "s" : [ {
                        "r" : "750",
                        "s" : [ {
                           "r" : "749",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "750",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "750",
               "locator" : "212:54-212:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "749",
                  "locator" : "212:54-212:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "748",
                  "locator" : "212:32-212:50",
                  "name" : "{http://hl7.org/fhir}ParticipationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "755",
            "locator" : "213:1-213:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "755",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "752",
                     "s" : [ {
                        "value" : [ "PaymentNoticeStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "754",
                     "s" : [ {
                        "r" : "754",
                        "s" : [ {
                           "r" : "753",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "754",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "754",
               "locator" : "213:54-213:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "753",
                  "locator" : "213:54-213:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "752",
                  "locator" : "213:32-213:50",
                  "name" : "{http://hl7.org/fhir}PaymentNoticeStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "759",
            "locator" : "214:1-214:72",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "759",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "756",
                     "s" : [ {
                        "value" : [ "PaymentReconciliationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "758",
                     "s" : [ {
                        "r" : "758",
                        "s" : [ {
                           "r" : "757",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "758",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "758",
               "locator" : "214:62-214:72",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "757",
                  "locator" : "214:62-214:66",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "756",
                  "locator" : "214:32-214:58",
                  "name" : "{http://hl7.org/fhir}PaymentReconciliationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "763",
            "locator" : "215:1-215:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "763",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "760",
                     "s" : [ {
                        "value" : [ "ProcedureStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "762",
                     "s" : [ {
                        "r" : "762",
                        "s" : [ {
                           "r" : "761",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "762",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "762",
               "locator" : "215:50-215:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "761",
                  "locator" : "215:50-215:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "760",
                  "locator" : "215:32-215:46",
                  "name" : "{http://hl7.org/fhir}ProcedureStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "767",
            "locator" : "216:1-216:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "767",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "764",
                     "s" : [ {
                        "value" : [ "PropertyRepresentation" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "766",
                     "s" : [ {
                        "r" : "766",
                        "s" : [ {
                           "r" : "765",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "766",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "766",
               "locator" : "216:57-216:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "765",
                  "locator" : "216:57-216:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "764",
                  "locator" : "216:32-216:53",
                  "name" : "{http://hl7.org/fhir}PropertyRepresentation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "771",
            "locator" : "217:1-217:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "771",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "768",
                     "s" : [ {
                        "value" : [ "PropertyType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "770",
                     "s" : [ {
                        "r" : "770",
                        "s" : [ {
                           "r" : "769",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "770",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "770",
               "locator" : "217:47-217:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "769",
                  "locator" : "217:47-217:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "768",
                  "locator" : "217:32-217:43",
                  "name" : "{http://hl7.org/fhir}PropertyType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "775",
            "locator" : "218:1-218:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "775",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "772",
                     "s" : [ {
                        "value" : [ "ProvenanceEntityRole" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "774",
                     "s" : [ {
                        "r" : "774",
                        "s" : [ {
                           "r" : "773",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "774",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "774",
               "locator" : "218:55-218:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "773",
                  "locator" : "218:55-218:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "772",
                  "locator" : "218:32-218:51",
                  "name" : "{http://hl7.org/fhir}ProvenanceEntityRole",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "779",
            "locator" : "219:1-219:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "779",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "776",
                     "s" : [ {
                        "value" : [ "PublicationStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "778",
                     "s" : [ {
                        "r" : "778",
                        "s" : [ {
                           "r" : "777",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "778",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "778",
               "locator" : "219:52-219:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "777",
                  "locator" : "219:52-219:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "776",
                  "locator" : "219:32-219:48",
                  "name" : "{http://hl7.org/fhir}PublicationStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "783",
            "locator" : "220:1-220:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "783",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "780",
                     "s" : [ {
                        "value" : [ "QualityType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "782",
                     "s" : [ {
                        "r" : "782",
                        "s" : [ {
                           "r" : "781",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "782",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "782",
               "locator" : "220:46-220:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "781",
                  "locator" : "220:46-220:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "780",
                  "locator" : "220:32-220:42",
                  "name" : "{http://hl7.org/fhir}QualityType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "787",
            "locator" : "221:1-221:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "787",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "784",
                     "s" : [ {
                        "value" : [ "QuantityComparator" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "786",
                     "s" : [ {
                        "r" : "786",
                        "s" : [ {
                           "r" : "785",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "786",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "786",
               "locator" : "221:53-221:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "785",
                  "locator" : "221:53-221:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "784",
                  "locator" : "221:32-221:49",
                  "name" : "{http://hl7.org/fhir}QuantityComparator",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "791",
            "locator" : "222:1-222:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "791",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "788",
                     "s" : [ {
                        "value" : [ "QuestionnaireItemOperator" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "790",
                     "s" : [ {
                        "r" : "790",
                        "s" : [ {
                           "r" : "789",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "790",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "790",
               "locator" : "222:60-222:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "789",
                  "locator" : "222:60-222:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "788",
                  "locator" : "222:32-222:56",
                  "name" : "{http://hl7.org/fhir}QuestionnaireItemOperator",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "795",
            "locator" : "223:1-223:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "795",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "792",
                     "s" : [ {
                        "value" : [ "QuestionnaireItemType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "794",
                     "s" : [ {
                        "r" : "794",
                        "s" : [ {
                           "r" : "793",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "794",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "794",
               "locator" : "223:56-223:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "793",
                  "locator" : "223:56-223:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "792",
                  "locator" : "223:32-223:52",
                  "name" : "{http://hl7.org/fhir}QuestionnaireItemType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "799",
            "locator" : "224:1-224:72",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "799",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "796",
                     "s" : [ {
                        "value" : [ "QuestionnaireResponseStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "798",
                     "s" : [ {
                        "r" : "798",
                        "s" : [ {
                           "r" : "797",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "798",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "798",
               "locator" : "224:62-224:72",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "797",
                  "locator" : "224:62-224:66",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "796",
                  "locator" : "224:32-224:58",
                  "name" : "{http://hl7.org/fhir}QuestionnaireResponseStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "803",
            "locator" : "225:1-225:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "803",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "800",
                     "s" : [ {
                        "value" : [ "ReferenceHandlingPolicy" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "802",
                     "s" : [ {
                        "r" : "802",
                        "s" : [ {
                           "r" : "801",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "802",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "802",
               "locator" : "225:58-225:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "801",
                  "locator" : "225:58-225:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "800",
                  "locator" : "225:32-225:54",
                  "name" : "{http://hl7.org/fhir}ReferenceHandlingPolicy",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "807",
            "locator" : "226:1-226:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "807",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "804",
                     "s" : [ {
                        "value" : [ "ReferenceVersionRules" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "806",
                     "s" : [ {
                        "r" : "806",
                        "s" : [ {
                           "r" : "805",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "806",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "806",
               "locator" : "226:56-226:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "805",
                  "locator" : "226:56-226:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "804",
                  "locator" : "226:32-226:52",
                  "name" : "{http://hl7.org/fhir}ReferenceVersionRules",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "811",
            "locator" : "227:1-227:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "811",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "808",
                     "s" : [ {
                        "value" : [ "ReferredDocumentStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "810",
                     "s" : [ {
                        "r" : "810",
                        "s" : [ {
                           "r" : "809",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "810",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "810",
               "locator" : "227:57-227:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "809",
                  "locator" : "227:57-227:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "808",
                  "locator" : "227:32-227:53",
                  "name" : "{http://hl7.org/fhir}ReferredDocumentStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "815",
            "locator" : "228:1-228:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "815",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "812",
                     "s" : [ {
                        "value" : [ "RelatedArtifactType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "814",
                     "s" : [ {
                        "r" : "814",
                        "s" : [ {
                           "r" : "813",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "814",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "814",
               "locator" : "228:54-228:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "813",
                  "locator" : "228:54-228:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "812",
                  "locator" : "228:32-228:50",
                  "name" : "{http://hl7.org/fhir}RelatedArtifactType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "819",
            "locator" : "229:1-229:62",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "819",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "816",
                     "s" : [ {
                        "value" : [ "RemittanceOutcome" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "818",
                     "s" : [ {
                        "r" : "818",
                        "s" : [ {
                           "r" : "817",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "818",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "818",
               "locator" : "229:52-229:62",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "817",
                  "locator" : "229:52-229:56",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "816",
                  "locator" : "229:32-229:48",
                  "name" : "{http://hl7.org/fhir}RemittanceOutcome",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "823",
            "locator" : "230:1-230:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "823",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "820",
                     "s" : [ {
                        "value" : [ "RepositoryType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "822",
                     "s" : [ {
                        "r" : "822",
                        "s" : [ {
                           "r" : "821",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "822",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "822",
               "locator" : "230:49-230:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "821",
                  "locator" : "230:49-230:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "820",
                  "locator" : "230:32-230:45",
                  "name" : "{http://hl7.org/fhir}RepositoryType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "827",
            "locator" : "231:1-231:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "827",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "824",
                     "s" : [ {
                        "value" : [ "RequestIntent" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "826",
                     "s" : [ {
                        "r" : "826",
                        "s" : [ {
                           "r" : "825",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "826",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "826",
               "locator" : "231:48-231:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "825",
                  "locator" : "231:48-231:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "824",
                  "locator" : "231:32-231:44",
                  "name" : "{http://hl7.org/fhir}RequestIntent",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "831",
            "locator" : "232:1-232:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "831",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "828",
                     "s" : [ {
                        "value" : [ "RequestPriority" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "830",
                     "s" : [ {
                        "r" : "830",
                        "s" : [ {
                           "r" : "829",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "830",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "830",
               "locator" : "232:50-232:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "829",
                  "locator" : "232:50-232:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "828",
                  "locator" : "232:32-232:46",
                  "name" : "{http://hl7.org/fhir}RequestPriority",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "835",
            "locator" : "233:1-233:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "835",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "832",
                     "s" : [ {
                        "value" : [ "RequestStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "834",
                     "s" : [ {
                        "r" : "834",
                        "s" : [ {
                           "r" : "833",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "834",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "834",
               "locator" : "233:48-233:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "833",
                  "locator" : "233:48-233:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "832",
                  "locator" : "233:32-233:44",
                  "name" : "{http://hl7.org/fhir}RequestStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "839",
            "locator" : "234:1-234:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "839",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "836",
                     "s" : [ {
                        "value" : [ "ResearchElementType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "838",
                     "s" : [ {
                        "r" : "838",
                        "s" : [ {
                           "r" : "837",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "838",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "838",
               "locator" : "234:54-234:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "837",
                  "locator" : "234:54-234:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "836",
                  "locator" : "234:32-234:50",
                  "name" : "{http://hl7.org/fhir}ResearchElementType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "843",
            "locator" : "235:1-235:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "843",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "840",
                     "s" : [ {
                        "value" : [ "ResearchStudyStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "842",
                     "s" : [ {
                        "r" : "842",
                        "s" : [ {
                           "r" : "841",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "842",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "842",
               "locator" : "235:54-235:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "841",
                  "locator" : "235:54-235:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "840",
                  "locator" : "235:32-235:50",
                  "name" : "{http://hl7.org/fhir}ResearchStudyStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "847",
            "locator" : "236:1-236:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "847",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "844",
                     "s" : [ {
                        "value" : [ "ResearchSubjectStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "846",
                     "s" : [ {
                        "r" : "846",
                        "s" : [ {
                           "r" : "845",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "846",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "846",
               "locator" : "236:56-236:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "845",
                  "locator" : "236:56-236:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "844",
                  "locator" : "236:32-236:52",
                  "name" : "{http://hl7.org/fhir}ResearchSubjectStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "851",
            "locator" : "237:1-237:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "851",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "848",
                     "s" : [ {
                        "value" : [ "ResourceType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "850",
                     "s" : [ {
                        "r" : "850",
                        "s" : [ {
                           "r" : "849",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "850",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "850",
               "locator" : "237:47-237:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "849",
                  "locator" : "237:47-237:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "848",
                  "locator" : "237:32-237:43",
                  "name" : "{http://hl7.org/fhir}ResourceType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "855",
            "locator" : "238:1-238:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "855",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "852",
                     "s" : [ {
                        "value" : [ "ResourceVersionPolicy" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "854",
                     "s" : [ {
                        "r" : "854",
                        "s" : [ {
                           "r" : "853",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "854",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "854",
               "locator" : "238:56-238:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "853",
                  "locator" : "238:56-238:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "852",
                  "locator" : "238:32-238:52",
                  "name" : "{http://hl7.org/fhir}ResourceVersionPolicy",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "859",
            "locator" : "239:1-239:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "859",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "856",
                     "s" : [ {
                        "value" : [ "ResponseType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "858",
                     "s" : [ {
                        "r" : "858",
                        "s" : [ {
                           "r" : "857",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "858",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "858",
               "locator" : "239:47-239:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "857",
                  "locator" : "239:47-239:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "856",
                  "locator" : "239:32-239:43",
                  "name" : "{http://hl7.org/fhir}ResponseType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "863",
            "locator" : "240:1-240:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "863",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "860",
                     "s" : [ {
                        "value" : [ "RestfulCapabilityMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "862",
                     "s" : [ {
                        "r" : "862",
                        "s" : [ {
                           "r" : "861",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "862",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "862",
               "locator" : "240:56-240:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "861",
                  "locator" : "240:56-240:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "860",
                  "locator" : "240:32-240:52",
                  "name" : "{http://hl7.org/fhir}RestfulCapabilityMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "867",
            "locator" : "241:1-241:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "867",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "864",
                     "s" : [ {
                        "value" : [ "RiskAssessmentStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "866",
                     "s" : [ {
                        "r" : "866",
                        "s" : [ {
                           "r" : "865",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "866",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "866",
               "locator" : "241:55-241:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "865",
                  "locator" : "241:55-241:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "864",
                  "locator" : "241:32-241:51",
                  "name" : "{http://hl7.org/fhir}RiskAssessmentStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "871",
            "locator" : "242:1-242:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "871",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "868",
                     "s" : [ {
                        "value" : [ "SPDXLicense" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "870",
                     "s" : [ {
                        "r" : "870",
                        "s" : [ {
                           "r" : "869",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "870",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "870",
               "locator" : "242:46-242:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "869",
                  "locator" : "242:46-242:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "868",
                  "locator" : "242:32-242:42",
                  "name" : "{http://hl7.org/fhir}SPDXLicense",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "875",
            "locator" : "243:1-243:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "875",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "872",
                     "s" : [ {
                        "value" : [ "SearchComparator" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "874",
                     "s" : [ {
                        "r" : "874",
                        "s" : [ {
                           "r" : "873",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "874",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "874",
               "locator" : "243:51-243:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "873",
                  "locator" : "243:51-243:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "872",
                  "locator" : "243:32-243:47",
                  "name" : "{http://hl7.org/fhir}SearchComparator",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "879",
            "locator" : "244:1-244:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "879",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "876",
                     "s" : [ {
                        "value" : [ "SearchEntryMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "878",
                     "s" : [ {
                        "r" : "878",
                        "s" : [ {
                           "r" : "877",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "878",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "878",
               "locator" : "244:50-244:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "877",
                  "locator" : "244:50-244:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "876",
                  "locator" : "244:32-244:46",
                  "name" : "{http://hl7.org/fhir}SearchEntryMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "883",
            "locator" : "245:1-245:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "883",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "880",
                     "s" : [ {
                        "value" : [ "SearchModifierCode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "882",
                     "s" : [ {
                        "r" : "882",
                        "s" : [ {
                           "r" : "881",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "882",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "882",
               "locator" : "245:53-245:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "881",
                  "locator" : "245:53-245:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "880",
                  "locator" : "245:32-245:49",
                  "name" : "{http://hl7.org/fhir}SearchModifierCode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "887",
            "locator" : "246:1-246:60",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "887",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "884",
                     "s" : [ {
                        "value" : [ "SearchParamType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "886",
                     "s" : [ {
                        "r" : "886",
                        "s" : [ {
                           "r" : "885",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "886",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "886",
               "locator" : "246:50-246:60",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "885",
                  "locator" : "246:50-246:54",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "884",
                  "locator" : "246:32-246:46",
                  "name" : "{http://hl7.org/fhir}SearchParamType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "891",
            "locator" : "247:1-247:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "891",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "888",
                     "s" : [ {
                        "value" : [ "SectionMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "890",
                     "s" : [ {
                        "r" : "890",
                        "s" : [ {
                           "r" : "889",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "890",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "890",
               "locator" : "247:46-247:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "889",
                  "locator" : "247:46-247:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "888",
                  "locator" : "247:32-247:42",
                  "name" : "{http://hl7.org/fhir}SectionMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "895",
            "locator" : "248:1-248:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "895",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "892",
                     "s" : [ {
                        "value" : [ "SequenceType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "894",
                     "s" : [ {
                        "r" : "894",
                        "s" : [ {
                           "r" : "893",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "894",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "894",
               "locator" : "248:47-248:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "893",
                  "locator" : "248:47-248:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "892",
                  "locator" : "248:32-248:43",
                  "name" : "{http://hl7.org/fhir}SequenceType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "899",
            "locator" : "249:1-249:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "899",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "896",
                     "s" : [ {
                        "value" : [ "ServiceRequestIntent" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "898",
                     "s" : [ {
                        "r" : "898",
                        "s" : [ {
                           "r" : "897",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "898",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "898",
               "locator" : "249:55-249:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "897",
                  "locator" : "249:55-249:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "896",
                  "locator" : "249:32-249:51",
                  "name" : "{http://hl7.org/fhir}ServiceRequestIntent",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "903",
            "locator" : "250:1-250:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "903",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "900",
                     "s" : [ {
                        "value" : [ "ServiceRequestPriority" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "902",
                     "s" : [ {
                        "r" : "902",
                        "s" : [ {
                           "r" : "901",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "902",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "902",
               "locator" : "250:57-250:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "901",
                  "locator" : "250:57-250:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "900",
                  "locator" : "250:32-250:53",
                  "name" : "{http://hl7.org/fhir}ServiceRequestPriority",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "907",
            "locator" : "251:1-251:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "907",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "904",
                     "s" : [ {
                        "value" : [ "ServiceRequestStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "906",
                     "s" : [ {
                        "r" : "906",
                        "s" : [ {
                           "r" : "905",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "906",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "906",
               "locator" : "251:55-251:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "905",
                  "locator" : "251:55-251:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "904",
                  "locator" : "251:32-251:51",
                  "name" : "{http://hl7.org/fhir}ServiceRequestStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "911",
            "locator" : "252:1-252:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "911",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "908",
                     "s" : [ {
                        "value" : [ "SlicingRules" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "910",
                     "s" : [ {
                        "r" : "910",
                        "s" : [ {
                           "r" : "909",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "910",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "910",
               "locator" : "252:47-252:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "909",
                  "locator" : "252:47-252:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "908",
                  "locator" : "252:32-252:43",
                  "name" : "{http://hl7.org/fhir}SlicingRules",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "915",
            "locator" : "253:1-253:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "915",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "912",
                     "s" : [ {
                        "value" : [ "SlotStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "914",
                     "s" : [ {
                        "r" : "914",
                        "s" : [ {
                           "r" : "913",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "914",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "914",
               "locator" : "253:45-253:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "913",
                  "locator" : "253:45-253:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "912",
                  "locator" : "253:32-253:41",
                  "name" : "{http://hl7.org/fhir}SlotStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "919",
            "locator" : "254:1-254:58",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "919",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "916",
                     "s" : [ {
                        "value" : [ "SortDirection" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "918",
                     "s" : [ {
                        "r" : "918",
                        "s" : [ {
                           "r" : "917",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "918",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "918",
               "locator" : "254:48-254:58",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "917",
                  "locator" : "254:48-254:52",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "916",
                  "locator" : "254:32-254:44",
                  "name" : "{http://hl7.org/fhir}SortDirection",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "923",
            "locator" : "255:1-255:72",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "923",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "920",
                     "s" : [ {
                        "value" : [ "SpecimenContainedPreference" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "922",
                     "s" : [ {
                        "r" : "922",
                        "s" : [ {
                           "r" : "921",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "922",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "922",
               "locator" : "255:62-255:72",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "921",
                  "locator" : "255:62-255:66",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "920",
                  "locator" : "255:32-255:58",
                  "name" : "{http://hl7.org/fhir}SpecimenContainedPreference",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "927",
            "locator" : "256:1-256:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "927",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "924",
                     "s" : [ {
                        "value" : [ "SpecimenStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "926",
                     "s" : [ {
                        "r" : "926",
                        "s" : [ {
                           "r" : "925",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "926",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "926",
               "locator" : "256:49-256:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "925",
                  "locator" : "256:49-256:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "924",
                  "locator" : "256:32-256:45",
                  "name" : "{http://hl7.org/fhir}SpecimenStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "931",
            "locator" : "257:1-257:51",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "931",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "928",
                     "s" : [ {
                        "value" : [ "Status" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "930",
                     "s" : [ {
                        "r" : "930",
                        "s" : [ {
                           "r" : "929",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "930",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "930",
               "locator" : "257:41-257:51",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "929",
                  "locator" : "257:41-257:45",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "928",
                  "locator" : "257:32-257:37",
                  "name" : "{http://hl7.org/fhir}Status",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "935",
            "locator" : "258:1-258:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "935",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "932",
                     "s" : [ {
                        "value" : [ "StrandType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "934",
                     "s" : [ {
                        "r" : "934",
                        "s" : [ {
                           "r" : "933",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "934",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "934",
               "locator" : "258:45-258:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "933",
                  "locator" : "258:45-258:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "932",
                  "locator" : "258:32-258:41",
                  "name" : "{http://hl7.org/fhir}StrandType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "939",
            "locator" : "259:1-259:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "939",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "936",
                     "s" : [ {
                        "value" : [ "StructureDefinitionKind" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "938",
                     "s" : [ {
                        "r" : "938",
                        "s" : [ {
                           "r" : "937",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "938",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "938",
               "locator" : "259:58-259:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "937",
                  "locator" : "259:58-259:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "936",
                  "locator" : "259:32-259:54",
                  "name" : "{http://hl7.org/fhir}StructureDefinitionKind",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "943",
            "locator" : "260:1-260:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "943",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "940",
                     "s" : [ {
                        "value" : [ "StructureMapContextType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "942",
                     "s" : [ {
                        "r" : "942",
                        "s" : [ {
                           "r" : "941",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "942",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "942",
               "locator" : "260:58-260:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "941",
                  "locator" : "260:58-260:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "940",
                  "locator" : "260:32-260:54",
                  "name" : "{http://hl7.org/fhir}StructureMapContextType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "947",
            "locator" : "261:1-261:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "947",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "944",
                     "s" : [ {
                        "value" : [ "StructureMapGroupTypeMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "946",
                     "s" : [ {
                        "r" : "946",
                        "s" : [ {
                           "r" : "945",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "946",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "946",
               "locator" : "261:60-261:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "945",
                  "locator" : "261:60-261:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "944",
                  "locator" : "261:32-261:56",
                  "name" : "{http://hl7.org/fhir}StructureMapGroupTypeMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "951",
            "locator" : "262:1-262:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "951",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "948",
                     "s" : [ {
                        "value" : [ "StructureMapInputMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "950",
                     "s" : [ {
                        "r" : "950",
                        "s" : [ {
                           "r" : "949",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "950",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "950",
               "locator" : "262:56-262:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "949",
                  "locator" : "262:56-262:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "948",
                  "locator" : "262:32-262:52",
                  "name" : "{http://hl7.org/fhir}StructureMapInputMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "955",
            "locator" : "263:1-263:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "955",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "952",
                     "s" : [ {
                        "value" : [ "StructureMapModelMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "954",
                     "s" : [ {
                        "r" : "954",
                        "s" : [ {
                           "r" : "953",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "954",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "954",
               "locator" : "263:56-263:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "953",
                  "locator" : "263:56-263:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "952",
                  "locator" : "263:32-263:52",
                  "name" : "{http://hl7.org/fhir}StructureMapModelMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "959",
            "locator" : "264:1-264:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "959",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "956",
                     "s" : [ {
                        "value" : [ "StructureMapSourceListMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "958",
                     "s" : [ {
                        "r" : "958",
                        "s" : [ {
                           "r" : "957",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "958",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "958",
               "locator" : "264:61-264:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "957",
                  "locator" : "264:61-264:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "956",
                  "locator" : "264:32-264:57",
                  "name" : "{http://hl7.org/fhir}StructureMapSourceListMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "963",
            "locator" : "265:1-265:71",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "963",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "960",
                     "s" : [ {
                        "value" : [ "StructureMapTargetListMode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "962",
                     "s" : [ {
                        "r" : "962",
                        "s" : [ {
                           "r" : "961",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "962",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "962",
               "locator" : "265:61-265:71",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "961",
                  "locator" : "265:61-265:65",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "960",
                  "locator" : "265:32-265:57",
                  "name" : "{http://hl7.org/fhir}StructureMapTargetListMode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "967",
            "locator" : "266:1-266:66",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "967",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "964",
                     "s" : [ {
                        "value" : [ "StructureMapTransform" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "966",
                     "s" : [ {
                        "r" : "966",
                        "s" : [ {
                           "r" : "965",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "966",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "966",
               "locator" : "266:56-266:66",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "965",
                  "locator" : "266:56-266:60",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "964",
                  "locator" : "266:32-266:52",
                  "name" : "{http://hl7.org/fhir}StructureMapTransform",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "971",
            "locator" : "267:1-267:68",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "971",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "968",
                     "s" : [ {
                        "value" : [ "SubscriptionChannelType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "970",
                     "s" : [ {
                        "r" : "970",
                        "s" : [ {
                           "r" : "969",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "970",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "970",
               "locator" : "267:58-267:68",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "969",
                  "locator" : "267:58-267:62",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "968",
                  "locator" : "267:32-267:54",
                  "name" : "{http://hl7.org/fhir}SubscriptionChannelType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "975",
            "locator" : "268:1-268:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "975",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "972",
                     "s" : [ {
                        "value" : [ "SubscriptionStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "974",
                     "s" : [ {
                        "r" : "974",
                        "s" : [ {
                           "r" : "973",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "974",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "974",
               "locator" : "268:53-268:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "973",
                  "locator" : "268:53-268:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "972",
                  "locator" : "268:32-268:49",
                  "name" : "{http://hl7.org/fhir}SubscriptionStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "979",
            "locator" : "269:1-269:65",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "979",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "976",
                     "s" : [ {
                        "value" : [ "SupplyDeliveryStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "978",
                     "s" : [ {
                        "r" : "978",
                        "s" : [ {
                           "r" : "977",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "978",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "978",
               "locator" : "269:55-269:65",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "977",
                  "locator" : "269:55-269:59",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "976",
                  "locator" : "269:32-269:51",
                  "name" : "{http://hl7.org/fhir}SupplyDeliveryStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "983",
            "locator" : "270:1-270:64",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "983",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "980",
                     "s" : [ {
                        "value" : [ "SupplyRequestStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "982",
                     "s" : [ {
                        "r" : "982",
                        "s" : [ {
                           "r" : "981",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "982",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "982",
               "locator" : "270:54-270:64",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "981",
                  "locator" : "270:54-270:58",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "980",
                  "locator" : "270:32-270:50",
                  "name" : "{http://hl7.org/fhir}SupplyRequestStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "987",
            "locator" : "271:1-271:69",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "987",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "984",
                     "s" : [ {
                        "value" : [ "SystemRestfulInteraction" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "986",
                     "s" : [ {
                        "r" : "986",
                        "s" : [ {
                           "r" : "985",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "986",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "986",
               "locator" : "271:59-271:69",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "985",
                  "locator" : "271:59-271:63",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "984",
                  "locator" : "271:32-271:55",
                  "name" : "{http://hl7.org/fhir}SystemRestfulInteraction",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "991",
            "locator" : "272:1-272:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "991",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "988",
                     "s" : [ {
                        "value" : [ "TaskIntent" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "990",
                     "s" : [ {
                        "r" : "990",
                        "s" : [ {
                           "r" : "989",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "990",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "990",
               "locator" : "272:45-272:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "989",
                  "locator" : "272:45-272:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "988",
                  "locator" : "272:32-272:41",
                  "name" : "{http://hl7.org/fhir}TaskIntent",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "995",
            "locator" : "273:1-273:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "995",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "992",
                     "s" : [ {
                        "value" : [ "TaskPriority" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "994",
                     "s" : [ {
                        "r" : "994",
                        "s" : [ {
                           "r" : "993",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "994",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "994",
               "locator" : "273:47-273:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "993",
                  "locator" : "273:47-273:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "992",
                  "locator" : "273:32-273:43",
                  "name" : "{http://hl7.org/fhir}TaskPriority",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "999",
            "locator" : "274:1-274:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "999",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "996",
                     "s" : [ {
                        "value" : [ "TaskStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "998",
                     "s" : [ {
                        "r" : "998",
                        "s" : [ {
                           "r" : "997",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "998",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "998",
               "locator" : "274:45-274:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "997",
                  "locator" : "274:45-274:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "996",
                  "locator" : "274:32-274:41",
                  "name" : "{http://hl7.org/fhir}TaskStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1003",
            "locator" : "275:1-275:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1003",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1000",
                     "s" : [ {
                        "value" : [ "TestReportActionResult" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1002",
                     "s" : [ {
                        "r" : "1002",
                        "s" : [ {
                           "r" : "1001",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1002",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1002",
               "locator" : "275:57-275:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1001",
                  "locator" : "275:57-275:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1000",
                  "locator" : "275:32-275:53",
                  "name" : "{http://hl7.org/fhir}TestReportActionResult",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1007",
            "locator" : "276:1-276:70",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1007",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1004",
                     "s" : [ {
                        "value" : [ "TestReportParticipantType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1006",
                     "s" : [ {
                        "r" : "1006",
                        "s" : [ {
                           "r" : "1005",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1006",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1006",
               "locator" : "276:60-276:70",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1005",
                  "locator" : "276:60-276:64",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1004",
                  "locator" : "276:32-276:56",
                  "name" : "{http://hl7.org/fhir}TestReportParticipantType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1011",
            "locator" : "277:1-277:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1011",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1008",
                     "s" : [ {
                        "value" : [ "TestReportResult" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1010",
                     "s" : [ {
                        "r" : "1010",
                        "s" : [ {
                           "r" : "1009",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1010",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1010",
               "locator" : "277:51-277:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1009",
                  "locator" : "277:51-277:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1008",
                  "locator" : "277:32-277:47",
                  "name" : "{http://hl7.org/fhir}TestReportResult",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1015",
            "locator" : "278:1-278:61",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1015",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1012",
                     "s" : [ {
                        "value" : [ "TestReportStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1014",
                     "s" : [ {
                        "r" : "1014",
                        "s" : [ {
                           "r" : "1013",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1014",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1014",
               "locator" : "278:51-278:61",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1013",
                  "locator" : "278:51-278:55",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1012",
                  "locator" : "278:32-278:47",
                  "name" : "{http://hl7.org/fhir}TestReportStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1019",
            "locator" : "279:1-279:72",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1019",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1016",
                     "s" : [ {
                        "value" : [ "TestScriptRequestMethodCode" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1018",
                     "s" : [ {
                        "r" : "1018",
                        "s" : [ {
                           "r" : "1017",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1018",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1018",
               "locator" : "279:62-279:72",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1017",
                  "locator" : "279:62-279:66",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1016",
                  "locator" : "279:32-279:58",
                  "name" : "{http://hl7.org/fhir}TestScriptRequestMethodCode",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1023",
            "locator" : "280:1-280:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1023",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1020",
                     "s" : [ {
                        "value" : [ "TriggerType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1022",
                     "s" : [ {
                        "r" : "1022",
                        "s" : [ {
                           "r" : "1021",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1022",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1022",
               "locator" : "280:46-280:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1021",
                  "locator" : "280:46-280:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1020",
                  "locator" : "280:32-280:42",
                  "name" : "{http://hl7.org/fhir}TriggerType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1027",
            "locator" : "281:1-281:63",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1027",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1024",
                     "s" : [ {
                        "value" : [ "TypeDerivationRule" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1026",
                     "s" : [ {
                        "r" : "1026",
                        "s" : [ {
                           "r" : "1025",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1026",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1026",
               "locator" : "281:53-281:63",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1025",
                  "locator" : "281:53-281:57",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1024",
                  "locator" : "281:32-281:49",
                  "name" : "{http://hl7.org/fhir}TypeDerivationRule",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1031",
            "locator" : "282:1-282:67",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1031",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1028",
                     "s" : [ {
                        "value" : [ "TypeRestfulInteraction" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1030",
                     "s" : [ {
                        "r" : "1030",
                        "s" : [ {
                           "r" : "1029",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1030",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1030",
               "locator" : "282:57-282:67",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1029",
                  "locator" : "282:57-282:61",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1028",
                  "locator" : "282:32-282:53",
                  "name" : "{http://hl7.org/fhir}TypeRestfulInteraction",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1035",
            "locator" : "283:1-283:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1035",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1032",
                     "s" : [ {
                        "value" : [ "UDIEntryType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1034",
                     "s" : [ {
                        "r" : "1034",
                        "s" : [ {
                           "r" : "1033",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1034",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1034",
               "locator" : "283:47-283:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1033",
                  "locator" : "283:47-283:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1032",
                  "locator" : "283:32-283:43",
                  "name" : "{http://hl7.org/fhir}UDIEntryType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1039",
            "locator" : "284:1-284:56",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1039",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1036",
                     "s" : [ {
                        "value" : [ "UnitsOfTime" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1038",
                     "s" : [ {
                        "r" : "1038",
                        "s" : [ {
                           "r" : "1037",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1038",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1038",
               "locator" : "284:46-284:56",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1037",
                  "locator" : "284:46-284:50",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1036",
                  "locator" : "284:32-284:42",
                  "name" : "{http://hl7.org/fhir}UnitsOfTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1043",
            "locator" : "285:1-285:48",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1043",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1040",
                     "s" : [ {
                        "value" : [ "Use" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1042",
                     "s" : [ {
                        "r" : "1042",
                        "s" : [ {
                           "r" : "1041",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1042",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1042",
               "locator" : "285:38-285:48",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1041",
                  "locator" : "285:38-285:42",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1040",
                  "locator" : "285:32-285:34",
                  "name" : "{http://hl7.org/fhir}Use",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1047",
            "locator" : "286:1-286:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1047",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1044",
                     "s" : [ {
                        "value" : [ "VariableType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1046",
                     "s" : [ {
                        "r" : "1046",
                        "s" : [ {
                           "r" : "1045",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1046",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1046",
               "locator" : "286:47-286:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1045",
                  "locator" : "286:47-286:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1044",
                  "locator" : "286:32-286:43",
                  "name" : "{http://hl7.org/fhir}VariableType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1051",
            "locator" : "287:1-287:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1051",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1048",
                     "s" : [ {
                        "value" : [ "VisionBase" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1050",
                     "s" : [ {
                        "r" : "1050",
                        "s" : [ {
                           "r" : "1049",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1050",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1050",
               "locator" : "287:45-287:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1049",
                  "locator" : "287:45-287:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1048",
                  "locator" : "287:32-287:41",
                  "name" : "{http://hl7.org/fhir}VisionBase",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1055",
            "locator" : "288:1-288:55",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1055",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1052",
                     "s" : [ {
                        "value" : [ "VisionEyes" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1054",
                     "s" : [ {
                        "r" : "1054",
                        "s" : [ {
                           "r" : "1053",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1054",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1054",
               "locator" : "288:45-288:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1053",
                  "locator" : "288:45-288:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1052",
                  "locator" : "288:32-288:41",
                  "name" : "{http://hl7.org/fhir}VisionEyes",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1059",
            "locator" : "289:1-289:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1059",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1056",
                     "s" : [ {
                        "value" : [ "VisionStatus" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1058",
                     "s" : [ {
                        "r" : "1058",
                        "s" : [ {
                           "r" : "1057",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1058",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1058",
               "locator" : "289:47-289:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1057",
                  "locator" : "289:47-289:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1056",
                  "locator" : "289:32-289:43",
                  "name" : "{http://hl7.org/fhir}VisionStatus",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1063",
            "locator" : "290:1-290:59",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1063",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1060",
                     "s" : [ {
                        "value" : [ "XPathUsageType" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1062",
                     "s" : [ {
                        "r" : "1062",
                        "s" : [ {
                           "r" : "1061",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1062",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1062",
               "locator" : "290:49-290:59",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1061",
                  "locator" : "290:49-290:53",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1060",
                  "locator" : "290:32-290:45",
                  "name" : "{http://hl7.org/fhir}XPathUsageType",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1067",
            "locator" : "291:1-291:57",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1067",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1064",
                     "s" : [ {
                        "value" : [ "base64Binary" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1066",
                     "s" : [ {
                        "r" : "1066",
                        "s" : [ {
                           "r" : "1065",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1066",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1066",
               "locator" : "291:47-291:57",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1065",
                  "locator" : "291:47-291:51",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1064",
                  "locator" : "291:32-291:43",
                  "name" : "{http://hl7.org/fhir}base64Binary",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1071",
            "locator" : "292:1-292:53",
            "name" : "ToBoolean",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1071",
                  "s" : [ {
                     "value" : [ "define function ","ToBoolean","(","value"," " ]
                  }, {
                     "r" : "1068",
                     "s" : [ {
                        "value" : [ "boolean" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1070",
                     "s" : [ {
                        "r" : "1070",
                        "s" : [ {
                           "r" : "1069",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1070",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1070",
               "locator" : "292:43-292:53",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1069",
                  "locator" : "292:43-292:47",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1068",
                  "locator" : "292:33-292:39",
                  "name" : "{http://hl7.org/fhir}boolean",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1075",
            "locator" : "293:1-293:47",
            "name" : "ToDate",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1075",
                  "s" : [ {
                     "value" : [ "define function ","ToDate","(","value"," " ]
                  }, {
                     "r" : "1072",
                     "s" : [ {
                        "value" : [ "date" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1074",
                     "s" : [ {
                        "r" : "1074",
                        "s" : [ {
                           "r" : "1073",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1074",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1074",
               "locator" : "293:37-293:47",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1073",
                  "locator" : "293:37-293:41",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1072",
                  "locator" : "293:30-293:33",
                  "name" : "{http://hl7.org/fhir}date",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1079",
            "locator" : "294:1-294:55",
            "name" : "ToDateTime",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1079",
                  "s" : [ {
                     "value" : [ "define function ","ToDateTime","(","value"," " ]
                  }, {
                     "r" : "1076",
                     "s" : [ {
                        "value" : [ "dateTime" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1078",
                     "s" : [ {
                        "r" : "1078",
                        "s" : [ {
                           "r" : "1077",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1078",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1078",
               "locator" : "294:45-294:55",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1077",
                  "locator" : "294:45-294:49",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1076",
                  "locator" : "294:34-294:41",
                  "name" : "{http://hl7.org/fhir}dateTime",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1083",
            "locator" : "295:1-295:53",
            "name" : "ToDecimal",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1083",
                  "s" : [ {
                     "value" : [ "define function ","ToDecimal","(","value"," " ]
                  }, {
                     "r" : "1080",
                     "s" : [ {
                        "value" : [ "decimal" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1082",
                     "s" : [ {
                        "r" : "1082",
                        "s" : [ {
                           "r" : "1081",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1082",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1082",
               "locator" : "295:43-295:53",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1081",
                  "locator" : "295:43-295:47",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1080",
                  "locator" : "295:33-295:39",
                  "name" : "{http://hl7.org/fhir}decimal",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1087",
            "locator" : "296:1-296:54",
            "name" : "ToDateTime",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1087",
                  "s" : [ {
                     "value" : [ "define function ","ToDateTime","(","value"," " ]
                  }, {
                     "r" : "1084",
                     "s" : [ {
                        "value" : [ "instant" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1086",
                     "s" : [ {
                        "r" : "1086",
                        "s" : [ {
                           "r" : "1085",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1086",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1086",
               "locator" : "296:44-296:54",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1085",
                  "locator" : "296:44-296:48",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1084",
                  "locator" : "296:34-296:40",
                  "name" : "{http://hl7.org/fhir}instant",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1091",
            "locator" : "297:1-297:53",
            "name" : "ToInteger",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1091",
                  "s" : [ {
                     "value" : [ "define function ","ToInteger","(","value"," " ]
                  }, {
                     "r" : "1088",
                     "s" : [ {
                        "value" : [ "integer" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1090",
                     "s" : [ {
                        "r" : "1090",
                        "s" : [ {
                           "r" : "1089",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1090",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1090",
               "locator" : "297:43-297:53",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1089",
                  "locator" : "297:43-297:47",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1088",
                  "locator" : "297:33-297:39",
                  "name" : "{http://hl7.org/fhir}integer",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1095",
            "locator" : "298:1-298:51",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1095",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1092",
                     "s" : [ {
                        "value" : [ "string" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1094",
                     "s" : [ {
                        "r" : "1094",
                        "s" : [ {
                           "r" : "1093",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1094",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1094",
               "locator" : "298:41-298:51",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1093",
                  "locator" : "298:41-298:45",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1092",
                  "locator" : "298:32-298:37",
                  "name" : "{http://hl7.org/fhir}string",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1099",
            "locator" : "299:1-299:47",
            "name" : "ToTime",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1099",
                  "s" : [ {
                     "value" : [ "define function ","ToTime","(","value"," " ]
                  }, {
                     "r" : "1096",
                     "s" : [ {
                        "value" : [ "time" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1098",
                     "s" : [ {
                        "r" : "1098",
                        "s" : [ {
                           "r" : "1097",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1098",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1098",
               "locator" : "299:37-299:47",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1097",
                  "locator" : "299:37-299:41",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1096",
                  "locator" : "299:30-299:33",
                  "name" : "{http://hl7.org/fhir}time",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1103",
            "locator" : "300:1-300:48",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1103",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1100",
                     "s" : [ {
                        "value" : [ "uri" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1102",
                     "s" : [ {
                        "r" : "1102",
                        "s" : [ {
                           "r" : "1101",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1102",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1102",
               "locator" : "300:38-300:48",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1101",
                  "locator" : "300:38-300:42",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1100",
                  "locator" : "300:32-300:34",
                  "name" : "{http://hl7.org/fhir}uri",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1107",
            "locator" : "301:1-301:50",
            "name" : "ToString",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1107",
                  "s" : [ {
                     "value" : [ "define function ","ToString","(","value"," " ]
                  }, {
                     "r" : "1104",
                     "s" : [ {
                        "value" : [ "xhtml" ]
                     } ]
                  }, {
                     "value" : [ "): " ]
                  }, {
                     "r" : "1106",
                     "s" : [ {
                        "r" : "1106",
                        "s" : [ {
                           "r" : "1105",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "1106",
                           "s" : [ {
                              "value" : [ "value" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1106",
               "locator" : "301:40-301:50",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "1105",
                  "locator" : "301:40-301:44",
                  "name" : "value",
                  "type" : "OperandRef"
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "1104",
                  "locator" : "301:32-301:36",
                  "name" : "{http://hl7.org/fhir}xhtml",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         } ]
      }
   }
}" + } ] + }, + "request": { + "method": "PUT", + "url": "Library/library-FHIRHelpers-4.0.1" + } + }, { + "resource": { + "resourceType": "Procedure", + "id": "numer-EXM130-1", + "meta": { + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" ] + }, + "status": "completed", + "code": { + "coding": [ { + "system": "http://www.ama-assn.org/go/cpt", + "code": "44393", + "display": "Colonoscopy through stoma; with ablation of tumor(s), polyp(s), or other lesion(s) not amenable to removal by hot biopsy forceps, bipolar cautery or snare technique" + } ] + }, + "subject": { + "reference": "Patient/numer-EXM130" + }, + "performedPeriod": { + "start": "2010-01-01T00:00:00-06:00", + "end": "2010-01-01T01:00:00-07:00" + } + }, + "request": { + "method": "PUT", + "url": "Procedure/numer-EXM130-1" + } + } ] + } diff --git a/hapi-fhir-jpaserver-cql/src/test/resources/r4/provider/test-executable-value-set.json b/hapi-fhir-jpaserver-cql/src/test/resources/r4/provider/test-executable-value-set.json new file mode 100644 index 00000000000..aee3eb2aa2a --- /dev/null +++ b/hapi-fhir-jpaserver-cql/src/test/resources/r4/provider/test-executable-value-set.json @@ -0,0 +1,39 @@ +{ + "resourceType": "ValueSet", + "id": "test-executable-value-set", + "meta" : { + "profile" : [ + "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-executablevalueset" + ] + }, + "url": "http://test.com/fhir/ValueSet/test-executable-value-set", + "extension" : [ + { + "url" : "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-knowledgeCapability", + "valueCode" : "executable" + }, + { + "url" : "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-knowledgeRepresentationLevel", + "valueCode" : "executable" + }, + { + "url" : "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-usageWarning", + "valueString" : "This value set contains a point-in-time expansion enumerating the codes that meet the value set intent. As new versions of the code systems used by the value set are released, the contents of this expansion will need to be updated to incorporate newly defined codes that meet the value set intent. Before, and periodically during production use, the value set expansion contents SHOULD be updated. The value set expansion specifies the timestamp when the expansion was produced, SHOULD contain the parameters used for the expansion, and SHALL contain the codes that are obtained by evaluating the value set definition. If this is ONLY an executable value set, a distributable definition of the value set must be obtained to compute the updated expansion." + } + ], + "expansion": { + "timestamp" : "2020-03-26T17:39:09-06:00", + "contains" : [ + { + "system" : "http://test.com/codesystem/test", + "code" : "1234", + "display" : "1234" + }, + { + "system" : "http://test.com/codesystem/test", + "code" : "ABCD", + "display" : "ABCD" + } + ] + } + }