diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/.gitignore b/layers/plugins/org.eclipse.papyrus.layers.documentation/.gitignore
new file mode 100755
index 0000000..2f88269
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/.gitignore
@@ -0,0 +1 @@
+/docs
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/.project b/layers/plugins/org.eclipse.papyrus.layers.documentation/.project
new file mode 100755
index 0000000..b6abf41
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/.project
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.layers.documentation</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.oomph.version.VersionBuilder</name>
+			<arguments>
+				<dictionary>
+					<key>check.maven.pom</key>
+					<value>true</value>
+				</dictionary>
+				<dictionary>
+					<key>ignore.lower.bound.dependency.ranges</key>
+					<value>true</value>
+				</dictionary>
+				<dictionary>
+					<key>release.path</key>
+					<value>/org.eclipse.papyrus.releng.main.release/release.xml</value>
+				</dictionary>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.api.tools.apiAnalysisBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.oomph.version.VersionNature</nature>
+		<nature>org.eclipse.pde.api.tools.apiAnalysisNature</nature>
+	</natures>
+</projectDescription>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.core.resources.prefs b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.core.resources.prefs
new file mode 100755
index 0000000..896a9a5
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
\ No newline at end of file
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.core.runtime.prefs b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.core.runtime.prefs
new file mode 100755
index 0000000..5a0ad22
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.core.runtime.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+line.separator=\n
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.jdt.core.prefs b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.jdt.core.prefs
new file mode 100755
index 0000000..4d72ad1
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,288 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0
+org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
+org.eclipse.jdt.core.formatter.comment.line_length=260
+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=2
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=false
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.join_lines_in_comments=false
+org.eclipse.jdt.core.formatter.join_wrapped_lines=false
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.lineSplit=260
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=5
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
+org.eclipse.jdt.core.formatter.tabulation.char=tab
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.use_on_off_tags=false
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.jdt.ui.prefs b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.jdt.ui.prefs
new file mode 100755
index 0000000..954281d
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,68 @@
+cleanup.add_default_serial_version_id=true
+cleanup.add_generated_serial_version_id=false
+cleanup.add_missing_annotations=true
+cleanup.add_missing_deprecated_annotations=true
+cleanup.add_missing_methods=false
+cleanup.add_missing_nls_tags=false
+cleanup.add_missing_override_annotations=true
+cleanup.add_missing_override_annotations_interface_methods=true
+cleanup.add_serial_version_id=false
+cleanup.always_use_blocks=true
+cleanup.always_use_parentheses_in_expressions=false
+cleanup.always_use_this_for_non_static_field_access=false
+cleanup.always_use_this_for_non_static_method_access=false
+cleanup.convert_functional_interfaces=false
+cleanup.convert_to_enhanced_for_loop=false
+cleanup.correct_indentation=false
+cleanup.format_source_code=false
+cleanup.format_source_code_changes_only=false
+cleanup.insert_inferred_type_arguments=false
+cleanup.make_local_variable_final=true
+cleanup.make_parameters_final=false
+cleanup.make_private_fields_final=true
+cleanup.make_type_abstract_if_missing_method=false
+cleanup.make_variable_declarations_final=false
+cleanup.never_use_blocks=false
+cleanup.never_use_parentheses_in_expressions=true
+cleanup.organize_imports=false
+cleanup.qualify_static_field_accesses_with_declaring_class=false
+cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+cleanup.qualify_static_member_accesses_with_declaring_class=true
+cleanup.qualify_static_method_accesses_with_declaring_class=false
+cleanup.remove_private_constructors=true
+cleanup.remove_redundant_type_arguments=true
+cleanup.remove_trailing_whitespaces=true
+cleanup.remove_trailing_whitespaces_all=true
+cleanup.remove_trailing_whitespaces_ignore_empty=false
+cleanup.remove_unnecessary_casts=true
+cleanup.remove_unnecessary_nls_tags=true
+cleanup.remove_unused_imports=true
+cleanup.remove_unused_local_variables=false
+cleanup.remove_unused_private_fields=true
+cleanup.remove_unused_private_members=false
+cleanup.remove_unused_private_methods=true
+cleanup.remove_unused_private_types=true
+cleanup.sort_members=false
+cleanup.sort_members_all=false
+cleanup.use_anonymous_class_creation=false
+cleanup.use_blocks=true
+cleanup.use_blocks_only_for_return_and_throw=false
+cleanup.use_lambda=true
+cleanup.use_parentheses_in_expressions=false
+cleanup.use_this_for_non_static_field_access=false
+cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+cleanup.use_this_for_non_static_method_access=false
+cleanup.use_this_for_non_static_method_access_only_if_necessary=true
+cleanup.use_type_arguments=false
+cleanup_profile=_Papyrus
+cleanup_settings_version=2
+eclipse.preferences.version=1
+formatter_profile=_Papyrus
+formatter_settings_version=12
+org.eclipse.jdt.ui.ignorelowercasenames=true
+org.eclipse.jdt.ui.importorder=java;javax;org;com;
+org.eclipse.jdt.ui.javadoc=true
+org.eclipse.jdt.ui.ondemandthreshold=99
+org.eclipse.jdt.ui.staticondemandthreshold=99
+org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\n * @return the ${bare_field_name}\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\n * @param ${param} the ${bare_field_name} to set\n */</template><template autoinsert\="false" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\n * Constructor.\n *\n * ${tags}\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*****************************************************************************\n * Copyright (c) ${year} CEA LIST and others.\n * \n * All rights reserved. This program and the accompanying materials\n * are made available under the terms of the Eclipse Public License v1.0\n * which accompanies this distribution, and is available at\n * http\://www.eclipse.org/legal/epl-v10.html\n *\n * Contributors\:\n *   CEA LIST - Initial API and implementation\n *   \n *****************************************************************************/\n</template><template autoinsert\="true" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\n * @author ${user}\n *\n * ${tags}\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\n * \n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\n * ${tags}\n */</template><template autoinsert\="false" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/**\n * ${see_to_overridden}\n *\n * ${tags}\n */</template><template autoinsert\="false" context\="delegatecomment_context" deleted\="false" description\="Comment for delegate methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.delegatecomment" name\="delegatecomment">/**\n * ${see_to_target}\n *\n * ${tags}\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\n${package_declaration}\n\n${typecomment}\n${type_declaration}</template><template autoinsert\="true" context\="classbody_context" deleted\="false" description\="Code in new class type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.classbody" name\="classbody">\n</template><template autoinsert\="true" context\="interfacebody_context" deleted\="false" description\="Code in new interface type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.interfacebody" name\="interfacebody">\n</template><template autoinsert\="true" context\="enumbody_context" deleted\="false" description\="Code in new enum type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.enumbody" name\="enumbody">\n</template><template autoinsert\="true" context\="annotationbody_context" deleted\="false" description\="Code in new annotation type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.annotationbody" name\="annotationbody">\n</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.m2e.core.prefs b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.m2e.core.prefs
new file mode 100755
index 0000000..f897a7f
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.m2e.core.prefs
@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.pde.api.tools.prefs b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.pde.api.tools.prefs
new file mode 100755
index 0000000..23fb95e
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/.settings/org.eclipse.pde.api.tools.prefs
@@ -0,0 +1,98 @@
+ANNOTATION_ELEMENT_TYPE_ADDED_METHOD_WITHOUT_DEFAULT_VALUE=Error
+ANNOTATION_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_FIELD=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_METHOD=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+API_COMPONENT_ELEMENT_TYPE_REMOVED_API_TYPE=Error
+API_COMPONENT_ELEMENT_TYPE_REMOVED_REEXPORTED_API_TYPE=Error
+API_COMPONENT_ELEMENT_TYPE_REMOVED_REEXPORTED_TYPE=Error
+API_COMPONENT_ELEMENT_TYPE_REMOVED_TYPE=Error
+API_USE_SCAN_FIELD_SEVERITY=Error
+API_USE_SCAN_METHOD_SEVERITY=Error
+API_USE_SCAN_TYPE_SEVERITY=Error
+CLASS_ELEMENT_TYPE_ADDED_METHOD=Error
+CLASS_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+CLASS_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+CLASS_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+CLASS_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+CLASS_ELEMENT_TYPE_CHANGED_NON_ABSTRACT_TO_ABSTRACT=Error
+CLASS_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+CLASS_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+CLASS_ELEMENT_TYPE_REMOVED_CONSTRUCTOR=Error
+CLASS_ELEMENT_TYPE_REMOVED_FIELD=Error
+CLASS_ELEMENT_TYPE_REMOVED_METHOD=Error
+CLASS_ELEMENT_TYPE_REMOVED_SUPERCLASS=Error
+CLASS_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+CLASS_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+CONSTRUCTOR_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+CONSTRUCTOR_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+CONSTRUCTOR_ELEMENT_TYPE_CHANGED_VARARGS_TO_ARRAY=Error
+CONSTRUCTOR_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+ENUM_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+ENUM_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+ENUM_ELEMENT_TYPE_REMOVED_ENUM_CONSTANT=Error
+ENUM_ELEMENT_TYPE_REMOVED_FIELD=Error
+ENUM_ELEMENT_TYPE_REMOVED_METHOD=Error
+ENUM_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+FIELD_ELEMENT_TYPE_ADDED_VALUE=Error
+FIELD_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+FIELD_ELEMENT_TYPE_CHANGED_FINAL_TO_NON_FINAL_STATIC_CONSTANT=Error
+FIELD_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+FIELD_ELEMENT_TYPE_CHANGED_NON_STATIC_TO_STATIC=Error
+FIELD_ELEMENT_TYPE_CHANGED_STATIC_TO_NON_STATIC=Error
+FIELD_ELEMENT_TYPE_CHANGED_TYPE=Error
+FIELD_ELEMENT_TYPE_CHANGED_VALUE=Error
+FIELD_ELEMENT_TYPE_REMOVED_TYPE_ARGUMENT=Error
+FIELD_ELEMENT_TYPE_REMOVED_VALUE=Error
+ILLEGAL_EXTEND=Warning
+ILLEGAL_IMPLEMENT=Warning
+ILLEGAL_INSTANTIATE=Warning
+ILLEGAL_OVERRIDE=Warning
+ILLEGAL_REFERENCE=Warning
+INTERFACE_ELEMENT_TYPE_ADDED_FIELD=Ignore
+INTERFACE_ELEMENT_TYPE_ADDED_METHOD=Error
+INTERFACE_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+INTERFACE_ELEMENT_TYPE_ADDED_SUPER_INTERFACE_WITH_METHODS=Error
+INTERFACE_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+INTERFACE_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+INTERFACE_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_FIELD=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_METHOD=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+INVALID_ANNOTATION=Ignore
+INVALID_JAVADOC_TAG=Ignore
+INVALID_REFERENCE_IN_SYSTEM_LIBRARIES=Ignore
+LEAK_EXTEND=Warning
+LEAK_FIELD_DECL=Warning
+LEAK_IMPLEMENT=Warning
+LEAK_METHOD_PARAM=Warning
+LEAK_METHOD_RETURN_TYPE=Warning
+METHOD_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+METHOD_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+METHOD_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_ABSTRACT_TO_ABSTRACT=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_STATIC_TO_STATIC=Error
+METHOD_ELEMENT_TYPE_CHANGED_STATIC_TO_NON_STATIC=Error
+METHOD_ELEMENT_TYPE_CHANGED_VARARGS_TO_ARRAY=Error
+METHOD_ELEMENT_TYPE_REMOVED_ANNOTATION_DEFAULT_VALUE=Error
+METHOD_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+MISSING_EE_DESCRIPTIONS=Error
+TYPE_PARAMETER_ELEMENT_TYPE_ADDED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_ADDED_INTERFACE_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_CHANGED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_CHANGED_INTERFACE_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_REMOVED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_REMOVED_INTERFACE_BOUND=Error
+UNUSED_PROBLEM_FILTERS=Warning
+automatically_removed_unused_problem_filters=Enabled
+eclipse.preferences.version=1
+incompatible_api_component_version=Error
+incompatible_api_component_version_include_major_without_breaking_change=Disabled
+incompatible_api_component_version_include_minor_without_api_change=Disabled
+invalid_since_tag_version=Error
+malformed_since_tag=Error
+missing_since_tag=Warning
+report_api_breakage_when_major_version_incremented=Disabled
+report_resolution_errors_api_component=Warning
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/META-INF/MANIFEST.MF b/layers/plugins/org.eclipse.papyrus.layers.documentation/META-INF/MANIFEST.MF
new file mode 100755
index 0000000..f888b40
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/META-INF/MANIFEST.MF
@@ -0,0 +1,9 @@
+Manifest-Version: 1.0
+Require-Bundle: org.eclipse.help;bundle-version="[3.7.0,4.0.0)",
+ org.eclipse.papyrus.infra.doc;bundle-version="[1.2.0,2.0.0)"
+Bundle-Vendor: %providerName
+Bundle-Version: 1.2.0.qualifier
+Bundle-Name: %pluginName
+Bundle-Localization: plugin
+Bundle-ManifestVersion: 2
+Bundle-SymbolicName: org.eclipse.papyrus.layers.documentation;singleton:=true
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/about.html b/layers/plugins/org.eclipse.papyrus.layers.documentation/about.html
new file mode 100755
index 0000000..d35d5ae
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>June 5, 2007</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+
+</body>
+</html>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/build.properties b/layers/plugins/org.eclipse.papyrus.layers.documentation/build.properties
new file mode 100755
index 0000000..ad75593
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/build.properties
@@ -0,0 +1,7 @@
+bin.includes = META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               target/generated-eclipse-help/**,\
+               about.html
+src.includes = about.html,\
+				resources/
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.di b/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.di
new file mode 100755
index 0000000..fad0c3f
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.di
@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<di:SashWindowsMngr xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:di="http://www.eclipse.org/papyrus/0.7.0/sashdi">
+  <pageList>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_--sO0LZJEeK8zaQi-hvdlw"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_hBG18M9REeKO_rl5MA6s9A"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_uhhxMM9VEeKO_rl5MA6s9A"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_obL1sM-wEeKO_rl5MA6s9A"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_idQj4NIPEeKovM8ingMMQQ"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_6iyZcNIPEeKovM8ingMMQQ"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_g9wjMNITEeKovM8ingMMQQ"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_EvbecNLSEeKwWoA8j13SIg"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_-hv_gNNmEeKwWoA8j13SIg"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_12QZkNNnEeKwWoA8j13SIg"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_3zc0INNpEeKwWoA8j13SIg"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_TiMgUNRgEeKHbZ6TDsPmrQ"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_C6rDcNeMEeKpd73UUMObaQ"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_rVlkIEydEeObF6ELIGKT-g"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_uPIkIEydEeObF6ELIGKT-g"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_harzYFzGEeOeP67GJGKDkA"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_HLcwQFzPEeOeP67GJGKDkA"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_uQQgIXh8EeOlpfB_tZS-QA"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_GqKscXiMEeOlpfB_tZS-QA"/>
+    </availablePage>
+    <availablePage>
+      <emfPageIdentifier href="architecture-v3.notation#_qdZ18IeYEeOyqaF0O659SA"/>
+    </availablePage>
+  </pageList>
+  <sashModel currentSelection="//@sashModel/@windows.0/@children.0">
+    <windows>
+      <children xsi:type="di:TabFolder">
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_--sO0LZJEeK8zaQi-hvdlw"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_hBG18M9REeKO_rl5MA6s9A"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_uhhxMM9VEeKO_rl5MA6s9A"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_obL1sM-wEeKO_rl5MA6s9A"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_idQj4NIPEeKovM8ingMMQQ"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_6iyZcNIPEeKovM8ingMMQQ"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_g9wjMNITEeKovM8ingMMQQ"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_-hv_gNNmEeKwWoA8j13SIg"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_12QZkNNnEeKwWoA8j13SIg"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_uPIkIEydEeObF6ELIGKT-g"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_3zc0INNpEeKwWoA8j13SIg"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_TiMgUNRgEeKHbZ6TDsPmrQ"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_C6rDcNeMEeKpd73UUMObaQ"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_rVlkIEydEeObF6ELIGKT-g"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_harzYFzGEeOeP67GJGKDkA"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_HLcwQFzPEeOeP67GJGKDkA"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_uQQgIXh8EeOlpfB_tZS-QA"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_GqKscXiMEeOlpfB_tZS-QA"/>
+        </children>
+        <children>
+          <emfPageIdentifier href="architecture-v3.notation#_qdZ18IeYEeOyqaF0O659SA"/>
+        </children>
+      </children>
+    </windows>
+  </sashModel>
+</di:SashWindowsMngr>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.notation b/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.notation
new file mode 100755
index 0000000..fca3ef8
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.notation
@@ -0,0 +1,6901 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:notation="http://www.eclipse.org/gmf/runtime/1.0.2/notation" xmlns:uml="http://www.eclipse.org/uml2/4.0.0/UML">
+  <notation:Diagram xmi:id="_--sO0LZJEeK8zaQi-hvdlw" type="PapyrusUMLClassDiagram" name="overview" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_Iz1vALZKEeK8zaQi-hvdlw" type="2007" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Iz_gALZKEeK8zaQi-hvdlw" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Iz_gAbZKEeK8zaQi-hvdlw" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Iz_gArZKEeK8zaQi-hvdlw" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Iz_gA7ZKEeK8zaQi-hvdlw" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Iz_gBLZKEeK8zaQi-hvdlw" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Iz_gBbZKEeK8zaQi-hvdlw" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Iz_gBrZKEeK8zaQi-hvdlw" type="5026"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Iz_gB7ZKEeK8zaQi-hvdlw" type="7016">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Iz_gCLZKEeK8zaQi-hvdlw"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Iz_gCbZKEeK8zaQi-hvdlw" y="60" width="200" height="74"/>
+      </children>
+      <element xmi:type="uml:Package" href="architecture-v3.uml#_IygSQLZKEeK8zaQi-hvdlw"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Iz1vAbZKEeK8zaQi-hvdlw" x="162" y="192"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_KAehQbZKEeK8zaQi-hvdlw" type="2007" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_KAehQ7ZKEeK8zaQi-hvdlw" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_KAehRLZKEeK8zaQi-hvdlw" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_KAehRbZKEeK8zaQi-hvdlw" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_KAehRrZKEeK8zaQi-hvdlw" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_KAehR7ZKEeK8zaQi-hvdlw" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_KAehSLZKEeK8zaQi-hvdlw" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_KAehSbZKEeK8zaQi-hvdlw" type="5026"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_KAehSrZKEeK8zaQi-hvdlw" type="7016">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_KAehS7ZKEeK8zaQi-hvdlw"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_KAehTLZKEeK8zaQi-hvdlw"/>
+      </children>
+      <element xmi:type="uml:Package" href="architecture-v3.uml#_KAehQLZKEeK8zaQi-hvdlw"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_KAehQrZKEeK8zaQi-hvdlw" x="162" y="48"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_KxknALZKEeK8zaQi-hvdlw" type="2007" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_KxknArZKEeK8zaQi-hvdlw" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_KxknA7ZKEeK8zaQi-hvdlw" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_KxknBLZKEeK8zaQi-hvdlw" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_KxknBbZKEeK8zaQi-hvdlw" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_KxknBrZKEeK8zaQi-hvdlw" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_KxknB7ZKEeK8zaQi-hvdlw" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_KxknCLZKEeK8zaQi-hvdlw" type="5026"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_KxknCbZKEeK8zaQi-hvdlw" type="7016">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_KxknCrZKEeK8zaQi-hvdlw"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_KxknC7ZKEeK8zaQi-hvdlw"/>
+      </children>
+      <element xmi:type="uml:Package" href="architecture-v3.uml#_KxbdELZKEeK8zaQi-hvdlw"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_KxknAbZKEeK8zaQi-hvdlw" x="162" y="336"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_ShPUUL2QEeKKJJ5BmR3W3Q" type="2007" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ShP7YL2QEeKKJJ5BmR3W3Q" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ShP7Yb2QEeKKJJ5BmR3W3Q" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ShP7Yr2QEeKKJJ5BmR3W3Q" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ShP7Y72QEeKKJJ5BmR3W3Q" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ShP7ZL2QEeKKJJ5BmR3W3Q" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ShP7Zb2QEeKKJJ5BmR3W3Q" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ShQicL2QEeKKJJ5BmR3W3Q" type="5026"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ShQicb2QEeKKJJ5BmR3W3Q" type="7016">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_ShQicr2QEeKKJJ5BmR3W3Q"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ShQic72QEeKKJJ5BmR3W3Q"/>
+      </children>
+      <element xmi:type="uml:Package" href="architecture-v3.uml#_ShE8QL2QEeKKJJ5BmR3W3Q"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ShPUUb2QEeKKJJ5BmR3W3Q" x="162" y="480" width="415"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_--sO0bZJEeK8zaQi-hvdlw"/>
+    <element xmi:type="uml:Model" href="architecture-v3.uml#_-7kCULZJEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_NCpRwLZKEeK8zaQi-hvdlw" type="4008" source="_Iz1vALZKEeK8zaQi-hvdlw" target="_KxknALZKEeK8zaQi-hvdlw" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_NCpRw7ZKEeK8zaQi-hvdlw" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_NCpRxLZKEeK8zaQi-hvdlw" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_NCpRxbZKEeK8zaQi-hvdlw" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_NCpRxrZKEeK8zaQi-hvdlw" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_NCpRwbZKEeK8zaQi-hvdlw" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_NCWW0LZKEeK8zaQi-hvdlw"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_NCpRwrZKEeK8zaQi-hvdlw" points="[-7, 11, 0, -111]$[-7, 122, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_NDipoLZKEeK8zaQi-hvdlw" id="(0.375,0.89)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_NDipobZKEeK8zaQi-hvdlw" id="(0.385,0.02)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_OVNs4bZKEeK8zaQi-hvdlw" type="4008" source="_KAehQbZKEeK8zaQi-hvdlw" target="_Iz1vALZKEeK8zaQi-hvdlw" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_OVXd4LZKEeK8zaQi-hvdlw" visible="false" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_OVXd4bZKEeK8zaQi-hvdlw" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_OVXd4rZKEeK8zaQi-hvdlw" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_OVXd47ZKEeK8zaQi-hvdlw" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_OVNs4rZKEeK8zaQi-hvdlw" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_OVNs4LZKEeK8zaQi-hvdlw"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OVNs47ZKEeK8zaQi-hvdlw" points="[30, 34, -130, -142]$[116, 128, -44, -48]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OVXd5LZKEeK8zaQi-hvdlw" id="(0.575,0.94)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OVXd5bZKEeK8zaQi-hvdlw" id="(0.61,0.23)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_V2KBsL2QEeKKJJ5BmR3W3Q" type="4008" source="_KxknALZKEeK8zaQi-hvdlw" target="_ShPUUL2QEeKKJJ5BmR3W3Q" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_V2LP0L2QEeKKJJ5BmR3W3Q" visible="false" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_V2LP0b2QEeKKJJ5BmR3W3Q" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_V2L24L2QEeKKJJ5BmR3W3Q" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_V2L24b2QEeKKJJ5BmR3W3Q" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_V2KBsb2QEeKKJJ5BmR3W3Q" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_V114oL2QEeKKJJ5BmR3W3Q"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_V2KBsr2QEeKKJJ5BmR3W3Q" points="[5, -2, -158, 0]$[129, 1, -34, 3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_V2TysL2QEeKKJJ5BmR3W3Q" id="(0.68,0.96)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ybg2MHboEeOlpfB_tZS-QA" id="(0.3036144578313253,0.15)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_Xjg7YL2QEeKKJJ5BmR3W3Q" type="4008" source="_Iz1vALZKEeK8zaQi-hvdlw" target="_ShPUUL2QEeKKJJ5BmR3W3Q" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_XjiJgL2QEeKKJJ5BmR3W3Q" visible="false" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_XjiJgb2QEeKKJJ5BmR3W3Q" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_XjiJgr2QEeKKJJ5BmR3W3Q" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_XjiJg72QEeKKJJ5BmR3W3Q" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Xjg7Yb2QEeKKJJ5BmR3W3Q" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_Xjd4EL2QEeKKJJ5BmR3W3Q"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Xjg7Yr2QEeKKJJ5BmR3W3Q" points="[11, 10, -146, -130]$[151, 138, -6, -2]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_XjpeQL2QEeKKJJ5BmR3W3Q" id="(0.83,0.21)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_XjpeQb2QEeKKJJ5BmR3W3Q" id="(0.6313253012048192,0.14)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_hBG18M9REeKO_rl5MA6s9A" type="PapyrusUMLClassDiagram" name="ui" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_hxns4M9REeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hxr-UM9REeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hxslYM9REeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hxslYc9REeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hxslYs9REeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hxtMcM9REeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hxtMcc9REeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_hxtMcs9REeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hxtzgM9REeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hxtzgc9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hxtzgs9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hxtzg89REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hxtzhM9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hxtzhc9REeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hxtzhs9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hxtzh89REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hxtziM9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hxtzic9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hxtzis9REeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hxtzi89REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hxtzjM9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hxtzjc9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hxtzjs9REeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_hwJtQM9REeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hxns4c9REeKO_rl5MA6s9A" x="72" y="330"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_jf2JQM9REeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jf3XYM9REeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jf3-cM9REeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jf3-cc9REeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jf3-cs9REeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jf3-c89REeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jf3-dM9REeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_jf3-dc9REeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jf4lgM9REeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jf4lgc9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jf4lgs9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jf4lg89REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jf4lhM9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jf4lhc9REeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jf4lhs9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jf4lh89REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jf4liM9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jf4lic9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jf5MkM9REeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jf5Mkc9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jf5Mks9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jf5Mk89REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jf5MlM9REeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_jfm4sM9REeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jf2JQc9REeKO_rl5MA6s9A" x="654" y="582" width="140" height="91"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_l9IEAM9REeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l9JSIM9REeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l9JSIc9REeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l9JSIs9REeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l9JSI89REeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l9J5MM9REeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l9J5Mc9REeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_l9J5Ms9REeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l9J5M89REeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l9J5NM9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l9J5Nc9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l9J5Ns9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l9J5N89REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l9KgQM9REeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l9KgQc9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l9KgQs9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l9KgQ89REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l9KgRM9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l9KgRc9REeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l9KgRs9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l9KgR89REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l9KgSM9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l9KgSc9REeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_l8z68M9REeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l9IrEM9REeKO_rl5MA6s9A" x="498" y="582"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_nrSO8M9REeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_nrS2AM9REeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_nrTdEM9REeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_nrTdEc9REeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_nrTdEs9REeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_nrTdE89REeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_nrTdFM9REeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_nrTdFc9REeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nrUEIM9REeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nrUEIc9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nrUEIs9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nrUEI89REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nrUEJM9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nrUEJc9REeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nrUEJs9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nrUEJ89REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nrUEKM9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nrUEKc9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nrUEKs9REeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nrUEK89REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nrUELM9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nrUELc9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nrUELs9REeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_nrEMgM9REeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nrSO8c9REeKO_rl5MA6s9A" x="300" y="582"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_rc6tgM9REeKO_rl5MA6s9A" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rc77oM9REeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rc77oc9REeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rc77os9REeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rc77o89REeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rc77pM9REeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rc8isM9REeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_rc8isc9REeKO_rl5MA6s9A" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_rcDK0M9REeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rc6tgc9REeKO_rl5MA6s9A" x="570" y="192" width="105" height="99"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_yfNEgM9REeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_yfNrkM9REeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_yfOSoM9REeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_yfOSoc9REeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_yfOSos9REeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_yfOSo89REeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_yfOSpM9REeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_yfOSpc9REeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_yfOSps9REeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_yfOSp89REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_yfOSqM9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_yfOSqc9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_yfOSqs9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_yfO5sM9REeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_yfO5sc9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_yfO5ss9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_yfO5s89REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_yfO5tM9REeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_yfO5tc9REeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_yfO5ts9REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_yfO5t89REeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_yfO5uM9REeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_yfO5uc9REeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_yeyNwM9REeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_yfNEgc9REeKO_rl5MA6s9A" x="343" y="328"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_1THWkM9REeKO_rl5MA6s9A" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1TIksM9REeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1TIksc9REeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1TIkss9REeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1TIks89REeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1TIktM9REeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1TIktc9REeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_1TIkts9REeKO_rl5MA6s9A" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_1S4tEM9REeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_1THWkc9REeKO_rl5MA6s9A" x="72" y="66"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_OvFaoM9SEeKO_rl5MA6s9A" type="2012" fontName="Segoe UI" fillColor="13420443" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_OvH24M9SEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_OvH24c9SEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_OvH24s9SEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_OvId8M9SEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_OvId8c9SEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_OvId8s9SEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_OvId889SEeKO_rl5MA6s9A" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_-YSyYM9REeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OvFaoc9SEeKO_rl5MA6s9A" x="192" y="444"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_cxJAIM9SEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_cxKOQM9SEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_cxKOQc9SEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_cxKOQs9SEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_cxKOQ89SEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_cxKORM9SEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_cxKORc9SEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cxK1UM9SEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cxK1Uc9SEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cxK1Us9SEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cxK1U89SEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cxK1VM9SEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cxK1Vc9SEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cxK1Vs9SEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cxK1V89SEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cxK1WM9SEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cxK1Wc9SEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cxK1Ws9SEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cxK1W89SEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cxK1XM9SEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cxK1Xc9SEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cxK1Xs9SEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cxK1X89SEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_cw2FMM9SEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cxJnMM9SEeKO_rl5MA6s9A" x="336" y="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_G-Wz0M9TEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_G-Xa4M9TEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_G-Xa4c9TEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_G-Xa4s9TEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_G-Xa489TEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_G-Xa5M9TEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_G-YB8M9TEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_G-YB8c9TEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_G-YB8s9TEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_G-YB889TEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_G-YB9M9TEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_G-YB9c9TEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_G-YB9s9TEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_G-YB989TEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_G-YB-M9TEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_G-YB-c9TEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_G-YB-s9TEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_G-YB-89TEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_G-YB_M9TEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_G-YB_c9TEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_G-YB_s9TEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_G-YB_89TEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_G-YCAM9TEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_G-A1kM9TEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_G-Wz0c9TEeKO_rl5MA6s9A" x="546" y="318"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_LyYjgM9TEeKO_rl5MA6s9A" type="2012" fontName="Segoe UI" fillColor="13420443" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LyZxoM9TEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LyaYsM9TEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LyaYsc9TEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LyaYss9TEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Lya_wM9TEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Lya_wc9TEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Lya_ws9TEeKO_rl5MA6s9A" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_hEcoYM9SEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LyYjgc9TEeKO_rl5MA6s9A" x="270" y="12" width="269" height="130"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_rq_eYM9UEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rrAsgM9UEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rrAsgc9UEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rrAsgs9UEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rrAsg89UEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hhbX8M9VEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hhbX8c9VEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_rrBTkc9UEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rrBTks9UEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rrBTk89UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rrBTlM9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rrBTlc9UEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rrBTls9UEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rrBTl89UEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rrBTmM9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rrBTmc9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rrBTms9UEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rrBTm89UEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rrBTnM9UEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rrBTnc9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rrBTns9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rrBTn89UEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rrBToM9UEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rqknoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rq_eYc9UEeKO_rl5MA6s9A" x="540" y="756"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_t0oEYM9UEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_t0pSgM9UEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_t0pSgc9UEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_t0pSgs9UEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_t0pSg89UEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hhaw4M9VEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hhaw4c9VEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_t0pShs9UEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_t0p5kM9UEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_t0p5kc9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_t0p5ks9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_t0p5k89UEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_t0p5lM9UEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_t0p5lc9UEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_t0p5ls9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_t0p5l89UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_t0p5mM9UEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_t0p5mc9UEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_t0p5ms9UEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_t0p5m89UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_t0p5nM9UEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_t0p5nc9UEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_t0p5ns9UEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_t0NNoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_t0oEYc9UEeKO_rl5MA6s9A" x="750" y="756"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_hBG18c9REeKO_rl5MA6s9A"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_KAehQLZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_EdL3kM9TEeKO_rl5MA6s9A" type="4008" source="_yfNEgM9REeKO_rl5MA6s9A" target="_cxJAIM9SEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_EdNFsM9TEeKO_rl5MA6s9A" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_EdNFsc9TEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_EdNswM9TEeKO_rl5MA6s9A" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_EdNswc9TEeKO_rl5MA6s9A" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_EdL3kc9TEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_Ecf7EM9TEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_EdL3ks9TEeKO_rl5MA6s9A" points="[-7, -7, 0, 81]$[-13, -74, -6, 14]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_EdVokM9TEeKO_rl5MA6s9A" id="(0.41,0.07)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_EdWPoM9TEeKO_rl5MA6s9A" id="(0.37272727272727274,0.86)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_Sa8y8M9TEeKO_rl5MA6s9A" type="4002" source="_nrSO8M9REeKO_rl5MA6s9A" target="_G-Wz0M9TEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Sa-BEM9TEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Sa-BEc9TEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Sa8y8c9TEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_SaqfEM9TEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Sa8y8s9TEeKO_rl5MA6s9A" points="[8, -8, -182, 172]$[187, -172, -3, 8]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_SbC5kM9TEeKO_rl5MA6s9A" id="(0.6038961038961039,0.08)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_SbC5kc9TEeKO_rl5MA6s9A" id="(0.37,0.92)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_S56m4M9TEeKO_rl5MA6s9A" type="4002" source="_l9IEAM9REeKO_rl5MA6s9A" target="_G-Wz0M9TEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_S571AM9TEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S571Ac9TEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_S56m4c9TEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_S5l2wM9TEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_S56m4s9TEeKO_rl5MA6s9A" points="[2, -14, -28, 174]$[24, -178, -6, 10]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_S6AtgM9TEeKO_rl5MA6s9A" id="(0.44,0.14)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_S6Atgc9TEeKO_rl5MA6s9A" id="(0.26,0.9)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_TdRLkM9TEeKO_rl5MA6s9A" type="4002" source="_jf2JQM9REeKO_rl5MA6s9A" target="_G-Wz0M9TEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_TdSZsM9TEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_TdSZsc9TEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_TdRLkc9TEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_TdEXQM9TEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_TdRLks9TEeKO_rl5MA6s9A" points="[-8, -13, 99, 174]$[-109, -177, -2, 10]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_TdXSMM9TEeKO_rl5MA6s9A" id="(0.29285714285714287,0.14285714285714285)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_TdXSMc9TEeKO_rl5MA6s9A" id="(0.42,0.9)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="__DZ6AM9TEeKO_rl5MA6s9A" type="4001" source="_yfNEgM9REeKO_rl5MA6s9A" target="_G-Wz0M9TEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="__DbIIM9TEeKO_rl5MA6s9A" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__DbIIc9TEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__DbIIs9TEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__DbII89TEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__DbIJM9TEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__DbIJc9TEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__DbIJs9TEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__DbvMM9TEeKO_rl5MA6s9A" x="-23" y="24"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__DbvMc9TEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__DbvMs9TEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__DbvM89TEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__DbvNM9TEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="__DZ6Ac9TEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#__DARYM9TEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="__DZ6As9TEeKO_rl5MA6s9A" points="[8, 0, -120, -10]$[111, 10, -17, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="__DnVYM9TEeKO_rl5MA6s9A" id="(0.92,0.3)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="__DnVYc9TEeKO_rl5MA6s9A" id="(0.17,0.5)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_LhMQYM9UEeKO_rl5MA6s9A" type="4001" source="_hxns4M9REeKO_rl5MA6s9A" target="_yfNEgM9REeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_LhNegM9UEeKO_rl5MA6s9A" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_LhNegc9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_LhNegs9UEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_LhNeg89UEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_LhOFkM9UEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_LhOFkc9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_LhOFks9UEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_LhOFk89UEeKO_rl5MA6s9A" x="-35" y="19"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_LhOFlM9UEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_LhOFlc9UEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_LhOFls9UEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_LhOsoM9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_LhMQYc9UEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_Lg4HUM9UEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_LhMQYs9UEeKO_rl5MA6s9A" points="[9, -4, -195, 0]$[180, -18, -24, -14]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_LhYdoM9UEeKO_rl5MA6s9A" id="(0.91,0.37)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_LhYdoc9UEeKO_rl5MA6s9A" id="(0.24,0.35)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_w04wYM9UEeKO_rl5MA6s9A" type="4001" source="_l9IEAM9REeKO_rl5MA6s9A" target="_rq_eYM9UEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_w05-gM9UEeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_w05-gc9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_w05-gs9UEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_w05-g89UEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_w05-hM9UEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_w05-hc9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_w06lkM9UEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_w06lkc9UEeKO_rl5MA6s9A" x="-3" y="78"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_w06lks9UEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_w06lk89UEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_w06llM9UEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_w06llc9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_w04wYc9UEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_w0iyIM9UEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_w04wYs9UEeKO_rl5MA6s9A" points="[4, 10, 0, -78]$[1, 84, -3, -4]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_w1FksM9UEeKO_rl5MA6s9A" id="(0.63,0.9)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_w1Fksc9UEeKO_rl5MA6s9A" id="(0.25,0.04)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_455IoM9UEeKO_rl5MA6s9A" type="4001" source="_jf2JQM9REeKO_rl5MA6s9A" target="_rq_eYM9UEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_455vsM9UEeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_455vsc9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_456WwM9UEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_456Wwc9UEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_456Wws9UEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_456Ww89UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_456WxM9UEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_456Wxc9UEeKO_rl5MA6s9A" x="-53" y="-51"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_456Wxs9UEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_45690M9UEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_45690c9UEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_45690s9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_455Ioc9UEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_45kYgM9UEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_455Ios9UEeKO_rl5MA6s9A" points="[-6, 7, 71, -86]$[-76, 90, 1, -3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_46C5oM9UEeKO_rl5MA6s9A" id="(0.29285714285714287,0.9230769230769231)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_46C5oc9UEeKO_rl5MA6s9A" id="(0.78,0.03)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_5vqTAM9UEeKO_rl5MA6s9A" type="4001" source="_jf2JQM9REeKO_rl5MA6s9A" target="_t0oEYM9UEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_5vrhIM9UEeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5vrhIc9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5vrhIs9UEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5vrhI89UEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5vrhJM9UEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5vrhJc9UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5vrhJs9UEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5vrhJ89UEeKO_rl5MA6s9A" x="28" y="-61"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5vsIMM9UEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5vsIMc9UEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5vsIMs9UEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5vsIM89UEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_5vqTAc9UEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_5vWJ8M9UEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_5vqTAs9UEeKO_rl5MA6s9A" points="[5, 11, -46, -92]$[47, 94, -4, -9]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_5v0rEM9UEeKO_rl5MA6s9A" id="(0.5642857142857143,0.8791208791208791)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_5v0rEc9UEeKO_rl5MA6s9A" id="(0.34,0.09)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_uhhxMM9VEeKO_rl5MA6s9A" type="PapyrusUMLClassDiagram" name="stackmodel" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_vMhO8M9VEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vMjEIM9VEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vMjEIc9VEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vMjrMM9VEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vMjrMc9VEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vMjrMs9VEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vMjrM89VEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vMkSQM9VEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_vMkSQc9VEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_vMkSQs9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_vMkSQ89VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_vMkSRM9VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vMkSRc9VEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_vMk5UM9VEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_vMk5Uc9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_vMk5Us9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_vMk5U89VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vMk5VM9VEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_vMlgYM9VEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_vMlgYc9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_vMlgYs9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_vMlgY89VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vMlgZM9VEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_t0NNoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vMhO8c9VEeKO_rl5MA6s9A" x="210" y="282"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_ynMmEM9VEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ynNNIM9VEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ynNNIc9VEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ynNNIs9VEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ynNNI89VEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ynNNJM9VEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ynN0MM9VEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ynN0Mc9VEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_ynN0Ms9VEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_ynN0M89VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_ynN0NM9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_ynN0Nc9VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ynN0Ns9VEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_ynN0N89VEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_ynN0OM9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_ynN0Oc9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_ynN0Os9VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ynN0O89VEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_ynN0PM9VEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_ynObQM9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_ynObQc9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_ynObQs9VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ynObQ89VEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rqknoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ynMmEc9VEeKO_rl5MA6s9A" x="228" y="42"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_0RKNgM9VEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_0RK0kM9VEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_0RK0kc9VEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_0RK0ks9VEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_0RK0k89VEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_0RLboM9VEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_0RLboc9VEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_0RLbos9VEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_0RLbo89VEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_0RLbpM9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_0RLbpc9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_0RLbps9VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_0RLbp89VEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_0RLbqM9VEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_0RLbqc9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_0RLbqs9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_0RLbq89VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_0RLbrM9VEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_0RMCsM9VEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_0RMCsc9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_0RMCss9VEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_0RMCs89VEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_0RMCtM9VEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_0Q5HwM9VEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_0RKNgc9VEeKO_rl5MA6s9A" x="78" y="168"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_uhhxMc9VEeKO_rl5MA6s9A"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_KxbdELZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_3iNHgM9VEeKO_rl5MA6s9A" type="4001" source="_vMhO8M9VEeKO_rl5MA6s9A" target="_ynMmEM9VEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_3iOVoM9VEeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3iOVoc9VEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3iOVos9VEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3iOVo89VEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3iO8sM9VEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3iO8sc9VEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3iO8ss9VEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3iO8s89VEeKO_rl5MA6s9A" x="-9" y="51"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3iO8tM9VEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3iO8tc9VEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3iO8ts9VEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3iO8t89VEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_3iNHgc9VEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_3h0tAM9VEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_3iNHgs9VEeKO_rl5MA6s9A" points="[6, -12, 0, 148]$[7, -152, 1, 8]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_3iai4M9VEeKO_rl5MA6s9A" id="(0.7,0.12)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_3iai4c9VEeKO_rl5MA6s9A" id="(0.58,0.92)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_5PwOcM9VEeKO_rl5MA6s9A" type="4001" source="_ynMmEM9VEeKO_rl5MA6s9A" target="_0RKNgM9VEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_5PxckM9VEeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5Pxckc9VEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5Pxcks9VEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5Pxck89VEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5PxclM9VEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5Pxclc9VEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5Pxcls9VEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5PyDoM9VEeKO_rl5MA6s9A" x="31" y="39"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5PyDoc9VEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5PyDos9VEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5PyDo89VEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_5PyDpM9VEeKO_rl5MA6s9A" x="-26" y="-13"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_5PwOcc9VEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_5PcFYM9VEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_5PwOcs9VEeKO_rl5MA6s9A" points="[-7, 3, 82, -47]$[-88, 47, 1, -3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_5P6mgM9VEeKO_rl5MA6s9A" id="(0.07,0.79)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_5P6mgc9VEeKO_rl5MA6s9A" id="(0.68,0.03)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_55fvAM9VEeKO_rl5MA6s9A" type="4001" source="_0RKNgM9VEeKO_rl5MA6s9A" target="_vMhO8M9VEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_55g9IM9VEeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_55g9Ic9VEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_55g9Is9VEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_55g9I89VEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_55g9JM9VEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_55g9Jc9VEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_55hkMM9VEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_55hkMc9VEeKO_rl5MA6s9A" x="-20" y="29"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_55hkMs9VEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_55hkM89VEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_55iLQM9VEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_55iLQc9VEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_55fvAc9VEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_55Ll8M9VEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_55fvAs9VEeKO_rl5MA6s9A" points="[4, 3, -68, -45]$[54, 37, -18, -11]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_55qHEM9VEeKO_rl5MA6s9A" id="(0.78,0.97)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_55qHEc9VEeKO_rl5MA6s9A" id="(0.18,0.31)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_obL1sM-wEeKO_rl5MA6s9A" type="PapyrusUMLClassDiagram" name="Layer expr" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_q3ZZcM-wEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_q3ZZcs-wEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_q3ZZc8-wEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_q3ZZdM-wEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_q3ZZdc-wEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_q3ZZds-wEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_q3ZZd8-wEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_q3ZZeM-wEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_q3ZZec-wEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_q3ZZes-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_q3ZZe8-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_q3ZZfM-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_q3ZZfc-wEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_q3ZZfs-wEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_q3ZZf8-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_q3ZZgM-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_q3ZZgc-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_q3ZZgs-wEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_q3ZZg8-wEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_q3ZZhM-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_q3ZZhc-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_q3ZZhs-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_q3ZZh8-wEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_q3GegM-wEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_q3ZZcc-wEeKO_rl5MA6s9A" x="300" y="96" height="64"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_sae80M-wEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_sae80s-wEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_sae808-wEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_sae81M-wEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_sae81c-wEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_sae81s-wEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_sae818-wEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_sae82M-wEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_sae82c-wEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_sae82s-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_sae828-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_sae83M-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_sae83c-wEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_sae83s-wEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_sae838-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_sae84M-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_sae84c-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_sae84s-wEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_sae848-wEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_sae85M-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_sae85c-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_sae85s-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_sae858-wEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_saCQ4M-wEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_sae80c-wEeKO_rl5MA6s9A" x="120" y="228" width="169" height="55"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_uI4_YM-wEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uI4_Ys-wEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uI4_Y8-wEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uI4_ZM-wEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uJCJUM-wEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uJCJUc-wEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uJCJUs-wEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uJCJU8-wEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_uJCJVM-wEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_uJCJVc-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_uJCJVs-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_uJCJV8-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uJCJWM-wEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_uJCJWc-wEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_uJCJWs-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_uJCJW8-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_uJCJXM-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uJCJXc-wEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_uJCJXs-wEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_uJCJX8-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_uJCJYM-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_uJCJYc-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uJCJYs-wEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_uIcTcM-wEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uI4_Yc-wEeKO_rl5MA6s9A" x="684" y="222" height="61"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_zRZxUM-wEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_zRZxUs-wEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_zRZxU8-wEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_zRZxVM-wEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_zRZxVc-wEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_zRZxVs-wEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_zRZxV8-wEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_zRZxWM-wEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_zRZxWc-wEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_zRZxWs-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_zRZxW8-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_zRZxXM-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_zRZxXc-wEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_zRZxXs-wEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_zRZxX8-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_zRZxYM-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_zRZxYc-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_zRZxYs-wEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_zRZxY8-wEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_zRZxZM-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_zRZxZc-wEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_zRZxZs-wEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_zRZxZ8-wEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_zRG2YM-wEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_zRZxUc-wEeKO_rl5MA6s9A" x="174" y="348" height="51"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_cL1ugM-xEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_cL1ugs-xEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_cL1ug8-xEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_cL1uhM-xEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_cL1uhc-xEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_cL1uhs-xEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_cL1uh8-xEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cL1uiM-xEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cL_fgM-xEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cL_fgc-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cL_fgs-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cL_fg8-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cL_fhM-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cL_fhc-xEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cL_fhs-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cL_fh8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cL_fiM-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cL_fic-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cL_fis-xEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cL_fi8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cL_fjM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cL_fjc-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cL_fjs-xEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_cLZCkM-xEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cL1ugc-xEeKO_rl5MA6s9A" x="12" y="350" height="51"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_hqM0oM-xEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hqM0os-xEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hqM0o8-xEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hqM0pM-xEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hqM0pc-xEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hqM0ps-xEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hqM0p8-xEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_hqM0qM-xEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hqM0qc-xEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hqM0qs-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hqM0q8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hqM0rM-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hqM0rc-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hqM0rs-xEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hqM0r8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hqM0sM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hqM0sc-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hqM0ss-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hqM0s8-xEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hqM0tM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hqM0tc-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hqM0ts-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hqM0t8-xEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_hp55sM-xEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hqM0oc-xEeKO_rl5MA6s9A" x="89" y="443" height="55"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_jApDIM-xEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jApDIs-xEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jApDI8-xEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jApDJM-xEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jApDJc-xEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jApDJs-xEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jApDJ8-xEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_jApDKM-xEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jApDKc-xEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jApDKs-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jApDK8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jApDLM-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jApDLc-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jApDLs-xEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jApDL8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jApDMM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jApDMc-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jApDMs-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jApDM8-xEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jApDNM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jApDNc-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jApDNs-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jApDN8-xEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_jAMXMM-xEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jApDIc-xEeKO_rl5MA6s9A" x="270" y="444" height="55"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_t0dLAM-xEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_t0dLAs-xEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_t0dLA8-xEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_t0dLBM-xEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_t0dLBc-xEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_t0dLBs-xEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_t0dLB8-xEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_t0dLCM-xEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_t0dLCc-xEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_t0dLCs-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_t0dLC8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_t0dLDM-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_t0dLDc-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_t0dLDs-xEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_t0dLD8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_t0dLEM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_t0dLEc-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_t0dLEs-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_t0dLE8-xEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_t0dLFM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_t0dLFc-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_t0dLFs-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_t0dLF8-xEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_t0KQEM-xEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_t0dLAc-xEeKO_rl5MA6s9A" x="780" y="348" height="38"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_u7RpIM-xEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_u7RpIs-xEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_u7RpI8-xEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_u7RpJM-xEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_u7RpJc-xEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_u7RpJs-xEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_u7RpJ8-xEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_u7RpKM-xEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_u7RpKc-xEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_u7RpKs-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_u7RpK8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_u7RpLM-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_u7RpLc-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_u7RpLs-xEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_u7RpL8-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_u7RpMM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_u7RpMc-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_u7RpMs-xEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_u7RpM8-xEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_u7RpNM-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_u7RpNc-xEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_u7RpNs-xEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_u7RpN8-xEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_u6-HIM-xEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_u7RpIc-xEeKO_rl5MA6s9A" x="630" y="348" height="38"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_SaLKsM-yEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SaLxwM-yEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SaLxwc-yEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SaLxws-yEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SaMY0M-yEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SaMY0c-yEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SaMY0s-yEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_SaMY08-yEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SaMY1M-yEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SaMY1c-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SaMY1s-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SaMY18-yEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SaMY2M-yEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SaM_4M-yEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SaM_4c-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SaM_4s-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SaM_48-yEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SaM_5M-yEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SaM_5c-yEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SaM_5s-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SaM_58-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SaM_6M-yEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SaM_6c-yEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_SZ1McM-yEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SaLKsc-yEeKO_rl5MA6s9A" x="456" y="348" height="47"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_Uz6pQM-yEeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Uz73YM-yEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Uz73Yc-yEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Uz73Ys-yEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Uz8ecM-yEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Uz8ecc-yEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Uz8ecs-yEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Uz8ec8-yEeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Uz9FgM-yEeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Uz9Fgc-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Uz9Fgs-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Uz9Fg8-yEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Uz9FhM-yEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Uz9Fhc-yEeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Uz9Fhs-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Uz9Fh8-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Uz9FiM-yEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Uz9Fic-yEeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Uz9skM-yEeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Uz9skc-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Uz9sks-yEeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Uz9sk8-yEeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Uz9slM-yEeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_UzekYM-yEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Uz6pQc-yEeKO_rl5MA6s9A" x="534" y="468" height="61"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_ZtLo0M-zEeKO_rl5MA6s9A" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ZtLo0s-zEeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ZtLo08-zEeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ZtLo1M-zEeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ZtLo1c-zEeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ZtLo1s-zEeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ZtLo18-zEeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZtLo2M-zEeKO_rl5MA6s9A" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_KvpSgM-zEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ZtLo0c-zEeKO_rl5MA6s9A" x="306" y="258" width="283"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_kfEooM-0EeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_kfEoos-0EeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_kfEoo8-0EeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_kfEopM-0EeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_kfEopc-0EeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_kfEops-0EeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_kfEop8-0EeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_kfEoqM-0EeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_kfEoqc-0EeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_kfEoqs-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_kfEoq8-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_kfEorM-0EeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_kfEorc-0EeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_kfEors-0EeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_kfEor8-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_kfEosM-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_kfEosc-0EeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_kfEoss-0EeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_kfEos8-0EeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_kfEotM-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_kfEotc-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_kfEots-0EeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_kfEot8-0EeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_kextsM-0EeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_kfEooc-0EeKO_rl5MA6s9A" x="912" y="198" height="50"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_l5OScM-0EeKO_rl5MA6s9A" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l5OScs-0EeKO_rl5MA6s9A" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l5OSc8-0EeKO_rl5MA6s9A" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l5OSdM-0EeKO_rl5MA6s9A" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l5OSdc-0EeKO_rl5MA6s9A" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l5OSds-0EeKO_rl5MA6s9A" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l5OSd8-0EeKO_rl5MA6s9A" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_l5OSeM-0EeKO_rl5MA6s9A" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l5OSec-0EeKO_rl5MA6s9A" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l5OSes-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l5OSe8-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l5OSfM-0EeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l5OSfc-0EeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l5OSfs-0EeKO_rl5MA6s9A" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l5OSf8-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l5OSgM-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l5OSgc-0EeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l5OSgs-0EeKO_rl5MA6s9A"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l5OSg8-0EeKO_rl5MA6s9A" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l5OShM-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l5OShc-0EeKO_rl5MA6s9A"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l5OShs-0EeKO_rl5MA6s9A"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l5OSh8-0EeKO_rl5MA6s9A"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_l4yNkM-0EeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l5OScc-0EeKO_rl5MA6s9A" x="912" y="270" height="51"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_obL1sc-wEeKO_rl5MA6s9A"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_KxbdELZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_w9q0IM-wEeKO_rl5MA6s9A" type="4002" source="_sae80M-wEeKO_rl5MA6s9A" target="_q3ZZcM-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_w9q0I8-wEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_w9q0JM-wEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_w9q0Ic-wEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_w9X5MM-wEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_w9q0Is-wEeKO_rl5MA6s9A" points="[11, -7, -116, 71]$[126, -75, -1, 3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_w9q0Jc-wEeKO_rl5MA6s9A" id="(0.6335877862595419,0.07)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_w9q0Js-wEeKO_rl5MA6s9A" id="(0.4528301886792453,0.97)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_x2pqkM-wEeKO_rl5MA6s9A" type="4002" source="_uI4_YM-wEeKO_rl5MA6s9A" target="_q3ZZcM-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_x2pqk8-wEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_x2pqlM-wEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_x2pqkc-wEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_x2M-oM-wEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_x2pqks-wEeKO_rl5MA6s9A" points="[-17, -8, 160, 80]$[-179, -76, -2, 12]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_x2pqlc-wEeKO_rl5MA6s9A" id="(0.32,0.08)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_x2pqls-wEeKO_rl5MA6s9A" id="(0.44339622641509435,0.88)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_oo1asM-xEeKO_rl5MA6s9A" type="4002" source="_cL1ugM-xEeKO_rl5MA6s9A" target="_sae80M-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_oo1as8-xEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_oo1atM-xEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_oo1asc-xEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_ooh4sM-xEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_oo1ass-xEeKO_rl5MA6s9A" points="[11, -8, -103, 74]$[109, -75, -5, 7]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_oo1atc-xEeKO_rl5MA6s9A" id="(0.5675675675675675,0.1568627450980392)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_oo1ats-xEeKO_rl5MA6s9A" id="(0.3893129770992366,0.8727272727272727)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_peFnsM-xEeKO_rl5MA6s9A" type="4002" source="_zRZxUM-wEeKO_rl5MA6s9A" target="_sae80M-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_peFns8-xEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_peFntM-xEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_peFnsc-xEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_pd8dwM-xEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_peFnss-xEeKO_rl5MA6s9A" points="[-3, -8, 27, 74]$[-32, -73, -2, 9]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_pePYsM-xEeKO_rl5MA6s9A" id="(0.56,0.1568627450980392)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_pePYsc-xEeKO_rl5MA6s9A" id="(0.4732824427480916,0.8363636363636363)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_qGaL8M-xEeKO_rl5MA6s9A" type="4002" source="_hqM0oM-xEeKO_rl5MA6s9A" target="_zRZxUM-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_qGaL88-xEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qGaL9M-xEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_qGaL8c-xEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_qGHRAM-xEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_qGaL8s-xEeKO_rl5MA6s9A" points="[7, -7, -58, 55]$[50, -51, -15, 11]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qGaL9c-xEeKO_rl5MA6s9A" id="(0.45132743362831856,0.12727272727272726)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qGaL9s-xEeKO_rl5MA6s9A" id="(0.31,0.7843137254901961)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_qvCSMM-xEeKO_rl5MA6s9A" type="4002" source="_jApDIM-xEeKO_rl5MA6s9A" target="_zRZxUM-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_qvCSM8-xEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qvCSNM-xEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_qvCSMc-xEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_quvXQM-xEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_qvCSMs-xEeKO_rl5MA6s9A" points="[-9, -7, 64, 55]$[-72, -52, 1, 10]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qvLcIM-xEeKO_rl5MA6s9A" id="(0.3,0.12727272727272726)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qvLcIc-xEeKO_rl5MA6s9A" id="(0.53,0.803921568627451)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_yiMFcM-xEeKO_rl5MA6s9A" type="4002" source="_t0dLAM-xEeKO_rl5MA6s9A" target="_uI4_YM-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_yiVPYM-xEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_yiVPYc-xEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_yiMFcc-xEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_yiCUcM-xEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_yiMFcs-xEeKO_rl5MA6s9A" points="[14, -19, -58, 90]$[74, -78, 2, 31]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_zKW4sM-xEeKO_rl5MA6s9A" type="4002" source="_u7RpIM-xEeKO_rl5MA6s9A" target="_uI4_YM-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_zKW4s8-xEeKO_rl5MA6s9A" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_zKW4tM-xEeKO_rl5MA6s9A" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_zKW4sc-xEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_zKNHsM-xEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_zKW4ss-xEeKO_rl5MA6s9A" points="[-10, -8, 86, 71]$[-99, -68, -3, 11]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_zKgpsM-xEeKO_rl5MA6s9A" id="(0.29,0.21052631578947367)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_zKgpsc-xEeKO_rl5MA6s9A" id="(0.46,0.819672131147541)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_aw8BUM-yEeKO_rl5MA6s9A" type="4001" source="_zRZxUM-wEeKO_rl5MA6s9A" target="_SaLKsM-yEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_aw8BU8-yEeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_aw8BVM-yEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_aw8BVc-yEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_aw8BVs-yEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_aw8BV8-yEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_aw8BWM-yEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_aw8BWc-yEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_aw8BWs-yEeKO_rl5MA6s9A" x="-46" y="23"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_aw8BW8-yEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_aw8BXM-yEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_aw8BXc-yEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_aw8BXs-yEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_aw8BUc-yEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_awpGYM-yEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_aw8BUs-yEeKO_rl5MA6s9A" points="[7, -5, -111, 0]$[117, -6, -1, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_axFLQM-yEeKO_rl5MA6s9A" id="(0.93,0.43137254901960786)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_axFLQc-yEeKO_rl5MA6s9A" id="(0.008547008547008548,0.3617021276595745)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_mkIikM-yEeKO_rl5MA6s9A" type="4001" source="_SaLKsM-yEeKO_rl5MA6s9A" target="_Uz6pQM-yEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_mkIik8-yEeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mkIilM-yEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mkIilc-yEeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mkIils-yEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mkIil8-yEeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mkIimM-yEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mkIimc-yEeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mkIims-yEeKO_rl5MA6s9A" x="-16" y="33"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mkIim8-yEeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mkIinM-yEeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mkIinc-yEeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mkIins-yEeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_mkIikc-yEeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_mjiFoM-yEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_mkIiks-yEeKO_rl5MA6s9A" points="[3, 9, -29, -76]$[29, 82, -3, -3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_mkRsgM-yEeKO_rl5MA6s9A" id="(0.6068376068376068,0.8085106382978723)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_mkRsgc-yEeKO_rl5MA6s9A" id="(0.1984126984126984,0.03)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_rmU_MM-0EeKO_rl5MA6s9A" type="4001" source="_uI4_YM-wEeKO_rl5MA6s9A" target="_kfEooM-0EeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_rmU_M8-0EeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_rmU_NM-0EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_rmU_Nc-0EeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_rmU_Ns-0EeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_rmU_N8-0EeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_rmU_OM-0EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_rmU_Oc-0EeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_rmU_Os-0EeKO_rl5MA6s9A" x="-19" y="18"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_rmU_O8-0EeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_rmU_PM-0EeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_rmU_Pc-0EeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_rmU_Ps-0EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_rmU_Mc-0EeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_rmCEQM-0EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_rmU_Ms-0EeKO_rl5MA6s9A" points="[5, -1, -89, 14]$[91, -16, -3, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_rmewMM-0EeKO_rl5MA6s9A" id="(0.95,0.14754098360655737)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_rmewMc-0EeKO_rl5MA6s9A" id="(0.03,0.36)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_seJYAM-0EeKO_rl5MA6s9A" type="4001" source="_uI4_YM-wEeKO_rl5MA6s9A" target="_l5OScM-0EeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_seJYA8-0EeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_seJYBM-0EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_seJYBc-0EeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_seTJAM-0EeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_seTJAc-0EeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_seTJAs-0EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_seTJA8-0EeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_seTJBM-0EeKO_rl5MA6s9A" x="-44" y="22"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_seTJBc-0EeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_seTJBs-0EeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_seTJB8-0EeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_seTJCM-0EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_seJYAc-0EeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_sd2dEM-0EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_seJYAs-0EeKO_rl5MA6s9A" points="[5, 1, -90, -22]$[91, 22, -4, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_secS8M-0EeKO_rl5MA6s9A" id="(0.95,0.7049180327868853)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_secS8c-0EeKO_rl5MA6s9A" id="(0.04,0.35294117647058826)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_OF2xoM-5EeKO_rl5MA6s9A" type="4001" source="_l5OScM-0EeKO_rl5MA6s9A" target="_Uz6pQM-yEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_OF2xo8-5EeKO_rl5MA6s9A" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_OF2xpM-5EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_OF2xpc-5EeKO_rl5MA6s9A" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_OF2xps-5EeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_OF2xp8-5EeKO_rl5MA6s9A" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_OF2xqM-5EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_OF2xqc-5EeKO_rl5MA6s9A" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_OF2xqs-5EeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_OF2xq8-5EeKO_rl5MA6s9A" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_OF2xrM-5EeKO_rl5MA6s9A" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_OF2xrc-5EeKO_rl5MA6s9A" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_OF2xrs-5EeKO_rl5MA6s9A" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_OF2xoc-5EeKO_rl5MA6s9A" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_OFj2sM-5EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OF2xos-5EeKO_rl5MA6s9A" points="[0, 9, 313, -186]$[0, 195, 313, 0]$[-308, 195, 5, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OGAioM-5EeKO_rl5MA6s9A" id="(0.56,0.8235294117647058)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OGAioc-5EeKO_rl5MA6s9A" id="(0.9603174603174603,0.639344262295082)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_JmkXINIPEeKovM8ingMMQQ" type="4001" source="_sae80M-wEeKO_rl5MA6s9A" target="_q3ZZcM-wEeKO_rl5MA6s9A" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_JmqdwNIPEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_JmqdwdIPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_JmqdwtIPEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Jmqdw9IPEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_JmqdxNIPEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_JmqdxdIPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_JmqdxtIPEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Jmqdx9IPEeKovM8ingMMQQ" x="-20" y="19"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_JmqdyNIPEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_JmqdydIPEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_JmqdytIPEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Jmqdy9IPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_JmkXIdIPEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_JlCtINIPEeKovM8ingMMQQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_JmkXItIPEeKovM8ingMMQQ" points="[0, -4, -144, 99]$[0, -103, -144, 0]$[136, -103, -8, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Jm8xoNIPEeKovM8ingMMQQ" id="(0.2047244094488189,0.07272727272727272)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Jm8xodIPEeKovM8ingMMQQ" id="(0.07692307692307693,0.515625)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_idQj4NIPEeKovM8ingMMQQ" type="PapyrusUMLClassDiagram" name="Layer" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_jH8foNIPEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jICmQNIPEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jICmQdIPEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jICmQtIPEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jICmQ9IPEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jICmRNIPEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jICmRdIPEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_jICmRtIPEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jICmR9IPEeKovM8ingMMQQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jICmSNIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jICmSdIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jICmStIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jICmS9IPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jICmTNIPEeKovM8ingMMQQ" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_AaCaENeJEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A9OxQNeKEeKpd73UUMObaQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_DPGtQNeKEeKpd73UUMObaQ" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_AYzD8NeJEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_AaCaEdeJEeKpd73UUMObaQ"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_ssnXwNeJEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A9OxRNeKEeKpd73UUMObaQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_DPGtQteKEeKpd73UUMObaQ" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_aJy80NeJEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_ssnXwdeJEeKpd73UUMObaQ" x="64" y="57"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_ssteYNeJEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A9OxRteKEeKpd73UUMObaQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_DPGtQ9eKEeKpd73UUMObaQ" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_aou7kNeJEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_ssteYdeJEeKpd73UUMObaQ" x="64" y="57"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_5Q3igNeJEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A9OxSNeKEeKpd73UUMObaQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_DPGtRNeKEeKpd73UUMObaQ" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_urYKgNeJEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_5Q3igdeJEeKpd73UUMObaQ" x="73" y="138"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_5Q9pINeJEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A9OxQteKEeKpd73UUMObaQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_DPGtQdeKEeKpd73UUMObaQ" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_urhUcNeJEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_5Q9pIdeJEeKpd73UUMObaQ" x="73" y="138"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_5Q9pIteJEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A9U34NeKEeKpd73UUMObaQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_DPGtRdeKEeKpd73UUMObaQ" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_uropMNeJEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_5RDvwNeJEeKpd73UUMObaQ" x="73" y="138"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jICmTdIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jICmTtIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jICmT9IPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jICmUNIPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jICmUdIPEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jICmUtIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jICmU9IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jICmVNIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jICmVdIPEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_uIcTcM-wEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jH8fodIPEeKovM8ingMMQQ" x="174" y="6" width="322" height="535"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_j6mEkNIPEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_j6sLMNIPEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_j6sLMdIPEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_j6sLMtIPEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_j6sLM9IPEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_j6sLNNIPEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_j6sLNdIPEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_j6sLNtIPEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_j6sLN9IPEeKovM8ingMMQQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_j6sLONIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_j6sLOdIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_j6sLOtIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_j6sLO9IPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_j6sLPNIPEeKovM8ingMMQQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_j6sLPdIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_j6sLPtIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_j6sLP9IPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_j6sLQNIPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_j6sLQdIPEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_j6sLQtIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_j6sLQ9IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_j6sLRNIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_j6sLRdIPEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_kextsM-0EeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_j6mEkdIPEeKovM8ingMMQQ" x="670" y="5"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_ke0L8NIPEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ke6SkNIPEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ke6SkdIPEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ke6SktIPEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ke6Sk9IPEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_ke6SlNIPEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_ke6SldIPEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ke6SltIPEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_ke6Sl9IPEeKovM8ingMMQQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_ke6SmNIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_ke6SmdIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_ke6SmtIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ke6Sm9IPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_ke6SnNIPEeKovM8ingMMQQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_ke6SndIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_ke6SntIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_ke6Sn9IPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ke6SoNIPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_ke6SodIPEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_ke6SotIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_ke6So9IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_ke6SpNIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ke6SpdIPEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_l4yNkM-0EeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ke0L8dIPEeKovM8ingMMQQ" x="672" y="168"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_u2yFUNIPEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_u2yFUtIPEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_u2yFU9IPEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_u2yFVNIPEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_u2yFVdIPEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_u2yFVtIPEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_u2yFV9IPEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_u2yFWNIPEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_u2yFWdIPEeKovM8ingMMQQ" type="7017">
+        <children xmi:type="notation:Shape" xmi:id="_xNZXYNIPEeKovM8ingMMQQ" type="3012" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_xNNKINIPEeKovM8ingMMQQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_xNZXYdIPEeKovM8ingMMQQ"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_C88iUNIQEeKovM8ingMMQQ" type="3012" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_C8tRwNIQEeKovM8ingMMQQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_C88iUdIQEeKovM8ingMMQQ"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_u2yFWtIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_u2yFW9IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_u2yFXNIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_u2yFXdIPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_u2yFXtIPEeKovM8ingMMQQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_u2yFX9IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_u2yFYNIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_u2yFYdIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_u2yFYtIPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_u24L8NIPEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_u24L8dIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_u24L8tIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_u24L89IPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_u24L9NIPEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_UzekYM-yEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_u2yFUdIPEeKovM8ingMMQQ" x="672" y="318" height="157"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_idQj4dIPEeKovM8ingMMQQ"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_KxbdELZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_j6-fENIPEeKovM8ingMMQQ" type="4001" source="_jH8foNIPEeKovM8ingMMQQ" target="_j6mEkNIPEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_j6-fE9IPEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_j6-fFNIPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_j6-fFdIPEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_j6-fFtIPEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_j6-fF9IPEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_j6-fGNIPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_j6-fGdIPEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_j6-fGtIPEeKovM8ingMMQQ" x="-17" y="21"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_j6-fG9IPEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_j6-fHNIPEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_j6-fHdIPEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_j6-fHtIPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_j6-fEdIPEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_rmCEQM-0EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_j6-fEtIPEeKovM8ingMMQQ" points="[-50, -36, 222, 155]$[-272, -191, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_nK6l0NIPEeKovM8ingMMQQ" id="(0.976,0.08411214953271028)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_kfAZMNIPEeKovM8ingMMQQ" type="4001" source="_jH8foNIPEeKovM8ingMMQQ" target="_ke0L8NIPEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_kfGf0NIPEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_kfGf0dIPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_kfGf0tIPEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_kfGf09IPEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_kfGf1NIPEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_kfGf1dIPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_kfGf1tIPEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_kfGf19IPEeKovM8ingMMQQ" x="-44" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_kfGf2NIPEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_kfGf2dIPEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_kfGf2tIPEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_kfGf29IPEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_kfAZMdIPEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_sd2dEM-0EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_kfAZMtIPEeKovM8ingMMQQ" points="[-50, -36, 222, 155]$[-272, -191, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_n2qRgNIPEeKovM8ingMMQQ" id="(0.984,0.40373831775700936)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_PY4ekNIQEeKovM8ingMMQQ" type="4001" source="_jH8foNIPEeKovM8ingMMQQ" target="_u2yFUNIPEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_PY4ek9IQEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PY4elNIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PY4eldIQEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PY4eltIQEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PY4el9IQEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PY4emNIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PY4emdIQEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PY4emtIQEeKovM8ingMMQQ" x="-54" y="18"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PY4em9IQEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PY4enNIQEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PY4endIQEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PY4entIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_PY4ekdIQEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_PYgEENIQEeKovM8ingMMQQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_PY4ektIQEeKovM8ingMMQQ" points="[8, 0, -183, 0]$[184, -3, -7, -3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_PZF58NIQEeKovM8ingMMQQ" id="(0.96,0.6336448598130842)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_PZF58dIQEeKovM8ingMMQQ" id="(0.015037593984962405,0.1553398058252427)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_axq7wNIQEeKovM8ingMMQQ" type="4001" source="_ke0L8NIPEeKovM8ingMMQQ" target="_u2yFUNIPEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_axsJ4NIQEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_axsJ4dIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_axsJ4tIQEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_axsJ49IQEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_axsJ5NIQEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_axsw8NIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_axsw8dIQEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_axsw8tIQEeKovM8ingMMQQ" x="1" y="-56"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_axsw89IQEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_axsw9NIQEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_axtYANIQEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_axtYAdIQEeKovM8ingMMQQ" x="-10" y="32"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_axq7wdIQEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_OFj2sM-5EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_axq7wtIQEeKovM8ingMMQQ" points="[5, 50, -11, -101]$[10, 100, -6, -51]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_3yXq0NIQEeKovM8ingMMQQ" type="4001" source="_jH8foNIPEeKovM8ingMMQQ" target="_u2yFUNIPEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_3yXq09IQEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3yXq1NIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3yXq1dIQEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3ydxcNIQEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3ydxcdIQEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3ydxctIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3ydxc9IQEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3ydxdNIQEeKovM8ingMMQQ" x="-34" y="21"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3ydxddIQEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3ydxdtIQEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3ydxd9IQEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_3ydxeNIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_3yXq0dIQEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_3yFW8NIQEeKovM8ingMMQQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_3yXq0tIQEeKovM8ingMMQQ" points="[5, 2, -176, 0]$[181, 2, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_3yj4ENIQEeKovM8ingMMQQ" id="(0.94,0.7514018691588785)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_3yj4EdIQEeKovM8ingMMQQ" id="(0.0,0.6213592233009708)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="__9WvQNIQEeKovM8ingMMQQ" type="4001" source="_jH8foNIPEeKovM8ingMMQQ" target="_u2yFUNIPEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="__9X9YNIQEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__9X9YdIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__9X9YtIQEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__9X9Y9IQEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__9X9ZNIQEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__9X9ZdIQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__9X9ZtIQEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__9X9Z9IQEeKovM8ingMMQQ" x="-28" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__9X9aNIQEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__9X9adIQEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="__9X9atIQEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="__9X9a9IQEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="__9WvQdIQEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#__8-UwNIQEeKovM8ingMMQQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="__9WvQtIQEeKovM8ingMMQQ" points="[5, 3, -200, 0]$[193, 20, -12, 17]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="__9eEANIQEeKovM8ingMMQQ" id="(0.98,0.8392523364485981)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="__9eEAdIQEeKovM8ingMMQQ" id="(0.18045112781954886,0.89171974522293)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_6iyZcNIPEeKovM8ingMMQQ" type="PapyrusUMLClassDiagram" name="datatypes" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_70xlwNIPEeKovM8ingMMQQ" type="2009" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_70xlwtIPEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_70xlw9IPEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_70xlxNIPEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_70xlxdIPEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_70xlxtIPEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_70xlx9IPEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_70xlyNIPEeKovM8ingMMQQ" type="5032"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_70xlydIPEeKovM8ingMMQQ" type="7039">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_70xlytIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_70xly9IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_70xlzNIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_70xlzdIPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_70xlztIPEeKovM8ingMMQQ" type="7040">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_70xlz9IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_70xl0NIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_70xl0dIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_70xl0tIPEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:PrimitiveType" href="architecture-v3.uml#_70TEoNIPEeKovM8ingMMQQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_70xlwdIPEeKovM8ingMMQQ" x="84" y="66"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_9K5EINIPEeKovM8ingMMQQ" type="2009" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_9K5EItIPEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_9K5EI9IPEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_9K5EJNIPEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_9K5EJdIPEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_9K5EJtIPEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_9K5EJ9IPEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9K5EKNIPEeKovM8ingMMQQ" type="5032"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_9K5EKdIPEeKovM8ingMMQQ" type="7039">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_9K5EKtIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_9K5EK9IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_9K5ELNIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_9K5ELdIPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_9K_KwNIPEeKovM8ingMMQQ" type="7040">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_9K_KwdIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_9K_KwtIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_9K_Kw9IPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_9K_KxNIPEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:PrimitiveType" href="architecture-v3.uml#_9KgpoNIPEeKovM8ingMMQQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_9K5EIdIPEeKovM8ingMMQQ" x="84" y="180"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_-D6W0NIPEeKovM8ingMMQQ" type="2009" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-D6W0tIPEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-D6W09IPEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-D6W1NIPEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-D6W1dIPEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-D6W1tIPEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-D6W19IPEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_-D6W2NIPEeKovM8ingMMQQ" type="5032"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_-D6W2dIPEeKovM8ingMMQQ" type="7039">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_-D6W2tIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_-D6W29IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_-D6W3NIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-D6W3dIPEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_-D6W3tIPEeKovM8ingMMQQ" type="7040">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_-D6W39IPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_-D6W4NIPEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_-D6W4dIPEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-D6W4tIPEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:PrimitiveType" href="architecture-v3.uml#_-DoC8NIPEeKovM8ingMMQQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-D6W0dIPEeKovM8ingMMQQ" x="246" y="66"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_GifssNIQEeKovM8ingMMQQ" type="2009" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GifsstIQEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Gifss9IQEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GifstNIQEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GifstdIQEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GifsttIQEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Gifst9IQEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_GifsuNIQEeKovM8ingMMQQ" type="5032"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_GifsudIQEeKovM8ingMMQQ" type="7039">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_GifsutIQEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Gifsu9IQEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_GifsvNIQEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GifsvdIQEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_GifsvtIQEeKovM8ingMMQQ" type="7040">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Gifsv9IQEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_GifswNIQEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_GifswdIQEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GifswtIQEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:PrimitiveType" href="architecture-v3.uml#_GiHSMNIQEeKovM8ingMMQQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GifssdIQEeKovM8ingMMQQ" x="444" y="66"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_NwkWUNeJEeKpd73UUMObaQ" type="2009" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NwkWUteJEeKpd73UUMObaQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NwkWU9eJEeKpd73UUMObaQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NwkWVNeJEeKpd73UUMObaQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NwkWVdeJEeKpd73UUMObaQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NwkWVteJEeKpd73UUMObaQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NwkWV9eJEeKpd73UUMObaQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_NwkWWNeJEeKpd73UUMObaQ" type="5032"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_NwkWWdeJEeKpd73UUMObaQ" type="7039">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_NwkWWteJEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_NwkWW9eJEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_NwkWXNeJEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NwkWXdeJEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_NwkWXteJEeKpd73UUMObaQ" type="7040">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_NwkWX9eJEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_NwkWYNeJEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_NwkWYdeJEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NwkWYteJEeKpd73UUMObaQ"/>
+      </children>
+      <element xmi:type="uml:PrimitiveType" href="architecture-v3.uml#_NwL70NeJEeKpd73UUMObaQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NwkWUdeJEeKpd73UUMObaQ" x="333" y="203"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_6iyZcdIPEeKovM8ingMMQQ"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_4GLNENIPEeKovM8ingMMQQ"/>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_g9wjMNITEeKovM8ingMMQQ" type="PapyrusUMLClassDiagram" name="LayerExpression m()" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_iSAZUNITEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iSAZUtITEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iSAZU9ITEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iSAZVNITEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iSAZVdITEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iSAZVtITEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iSAZV9ITEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_iSAZWNITEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iSAZWdITEeKovM8ingMMQQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iSAZWtITEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iSAZW9ITEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iSAZXNITEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iSAZXdITEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iSAZXtITEeKovM8ingMMQQ" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="__lBAYNITEeKovM8ingMMQQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__6UQENIVEeKovM8ingMMQQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GWK5MNIWEeKovM8ingMMQQ" key="CustomAppearance_MaskValue" value="21258"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#__kusgNITEeKovM8ingMMQQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="__lBAYdITEeKovM8ingMMQQ"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_CEs5cNIVEeKovM8ingMMQQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__6UQEtIVEeKovM8ingMMQQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GWQ_0NIWEeKovM8ingMMQQ" key="CustomAppearance_MaskValue" value="21258"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_8L56ENIUEeKovM8ingMMQQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_CEs5cdIVEeKovM8ingMMQQ" x="78" y="52"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_aXw0sNIVEeKovM8ingMMQQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__6UQFNIVEeKovM8ingMMQQ" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GWQ_0dIWEeKovM8ingMMQQ" key="CustomAppearance_MaskValue" value="21258"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_LDqYgNIVEeKovM8ingMMQQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_aXw0sdIVEeKovM8ingMMQQ" x="42" y="65"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iSAZX9ITEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iSAZYNITEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iSAZYdITEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iSAZYtITEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iSAZY9ITEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iSAZZNITEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iSAZZdITEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iSAZZtITEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iSAZZ9ITEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_q3GegM-wEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iSAZUdITEeKovM8ingMMQQ" x="168" y="102" width="445" height="223"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_k6gsoNITEeKovM8ingMMQQ" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_k6gsotITEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_k6gso9ITEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_k6gspNITEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_k6gspdITEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_k6gsptITEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_k6gsp9ITEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_k6gsqNITEeKovM8ingMMQQ" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_k5v3oNITEeKovM8ingMMQQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_k6gsodITEeKovM8ingMMQQ" x="12" y="24"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_nf1owNIWEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_nf2P0NIWEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_nf2P0dIWEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_nf2P0tIWEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_nf2P09IWEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_nf224NIWEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_nf224dIWEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_nf224tIWEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nf2249IWEeKovM8ingMMQQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nf225NIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nf225dIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nf225tIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nf2259IWEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nf226NIWEeKovM8ingMMQQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nf226dIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nf226tIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nf2269IWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nf227NIWEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nf3d8NIWEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nf3d8dIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nf3d8tIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nf3d89IWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nf3d9NIWEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_uIcTcM-wEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nf1owdIWEeKovM8ingMMQQ" x="198" y="648" width="415" height="361"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_thQYoNIWEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_thQYotIWEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_thQYo9IWEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_thQYpNIWEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_thQYpdIWEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_thQYptIWEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_thQYp9IWEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_thQYqNIWEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_thQYqdIWEeKovM8ingMMQQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_thQYqtIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_thQYq9IWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_thQYrNIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_thQYrdIWEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_thQYrtIWEeKovM8ingMMQQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_thQYr9IWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_thQYsNIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_thQYsdIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_thQYstIWEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_thQYs9IWEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_thQYtNIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_thQYtdIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_thQYttIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_thQYt9IWEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_kextsM-0EeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_thQYodIWEeKovM8ingMMQQ" x="816" y="576" height="160"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_uES0QNIWEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uES0QtIWEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uES0Q9IWEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uES0RNIWEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uES0RdIWEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uES0RtIWEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uES0R9IWEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uES0SNIWEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_uES0SdIWEeKovM8ingMMQQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_uES0StIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_uES0S9IWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_uES0TNIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uES0TdIWEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_uES0TtIWEeKovM8ingMMQQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_uES0T9IWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_uES0UNIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_uES0UdIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uES0UtIWEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_uES0U9IWEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_uES0VNIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_uES0VdIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_uES0VtIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uES0V9IWEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_l4yNkM-0EeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uES0QdIWEeKovM8ingMMQQ" x="804" y="906"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_vQqgwNIWEeKovM8ingMMQQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vQqgwtIWEeKovM8ingMMQQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vQqgw9IWEeKovM8ingMMQQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vQqgxNIWEeKovM8ingMMQQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vQqgxdIWEeKovM8ingMMQQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vQqgxtIWEeKovM8ingMMQQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vQqgx9IWEeKovM8ingMMQQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vQqgyNIWEeKovM8ingMMQQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_vQqgydIWEeKovM8ingMMQQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_vQqgytIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_vQqgy9IWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_vQqgzNIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vQqgzdIWEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_vQwnYNIWEeKovM8ingMMQQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_vQwnYdIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_vQwnYtIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_vQwnY9IWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vQwnZNIWEeKovM8ingMMQQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_vQwnZdIWEeKovM8ingMMQQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_vQwnZtIWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_vQwnZ9IWEeKovM8ingMMQQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_vQwnaNIWEeKovM8ingMMQQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vQwnadIWEeKovM8ingMMQQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_UzekYM-yEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vQqgwdIWEeKovM8ingMMQQ" x="804" y="162" height="262"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_g9wjMdITEeKovM8ingMMQQ"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_KxbdELZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_ngDEINIWEeKovM8ingMMQQ" type="4002" source="_nf1owNIWEeKovM8ingMMQQ" target="_iSAZUNITEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_ngDrMNIWEeKovM8ingMMQQ" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ngDrMdIWEeKovM8ingMMQQ" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_ngDEIdIWEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_x2M-oM-wEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_ngDEItIWEeKovM8ingMMQQ" points="[0, 0, -390, -203]$[196, 102, -194, -101]"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qEGf0NIXEeKovM8ingMMQQ" id="(0.5483146067415731,0.9801980198019802)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_thisgNIWEeKovM8ingMMQQ" type="4001" source="_nf1owNIWEeKovM8ingMMQQ" target="_thQYoNIWEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_thisg9IWEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_thishNIWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_thishdIWEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_thishtIWEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_thish9IWEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_thisiNIWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_thisidIWEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_thisitIWEeKovM8ingMMQQ" x="-10" y="21"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_thisi9IWEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_thisjNIWEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_thisjdIWEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_thisjtIWEeKovM8ingMMQQ" x="-1" y="-21"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_thisgdIWEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_rmCEQM-0EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_thisgtIWEeKovM8ingMMQQ" points="[-29, -50, 376, 648]$[-405, -698, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_iqbuINIYEeKovM8ingMMQQ" id="(0.980722891566265,0.12188365650969529)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_k7gY4NIYEeKovM8ingMMQQ" id="(0.03,0.69375)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_uEfBgNIWEeKovM8ingMMQQ" type="4001" source="_nf1owNIWEeKovM8ingMMQQ" target="_uES0QNIWEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_uElIINIWEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uElIIdIWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uElIItIWEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uElII9IWEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uElIJNIWEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uElIJdIWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uElIJtIWEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uElIJ9IWEeKovM8ingMMQQ" x="-35" y="26"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uElIKNIWEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uElIKdIWEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uElIKtIWEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uElIK9IWEeKovM8ingMMQQ" x="5" y="-22"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_uEfBgdIWEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_sd2dEM-0EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_uEfBgtIWEeKovM8ingMMQQ" points="[-29, -50, 376, 648]$[-405, -698, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_A9aPUNIXEeKovM8ingMMQQ" id="(0.9734939759036144,0.8559556786703602)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_vQ2uANIWEeKovM8ingMMQQ" type="4001" source="_uES0QNIWEeKovM8ingMMQQ" target="_vQqgwNIWEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_vQ2uA9IWEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vQ2uBNIWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vQ2uBdIWEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vQ2uBtIWEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vQ2uB9IWEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vQ2uCNIWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vQ2uCdIWEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vQ2uCtIWEeKovM8ingMMQQ" x="65" y="-5"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vQ2uC9IWEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vQ2uDNIWEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vQ2uDdIWEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vQ2uDtIWEeKovM8ingMMQQ" x="5" y="-35"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_vQ2uAdIWEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_OFj2sM-5EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_vQ2uAtIWEeKovM8ingMMQQ" points="[50, -8, 37, 625]$[148, -8, 135, 625]$[148, -626, 135, 7]$[76, -626, 63, 7]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_yspfcNIWEeKovM8ingMMQQ" type="4001" source="_iSAZUNITEeKovM8ingMMQQ" target="_vQqgwNIWEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_ysvmENIWEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ysvmEdIWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ysvmEtIWEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ysvmE9IWEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ysvmFNIWEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ysvmFdIWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ysvmFtIWEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ysvmF9IWEeKovM8ingMMQQ" x="-40" y="14"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ysvmGNIWEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ysvmGdIWEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ysvmGtIWEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ysvmG9IWEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_yspfcdIWEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_3yFW8NIQEeKovM8ingMMQQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_yspfctIWEeKovM8ingMMQQ" points="[55, -50, -245, 220]$[244, -220, -56, 50]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_AVTGcNIXEeKovM8ingMMQQ" id="(0.9932584269662922,0.4304932735426009)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_M5IacNIXEeKovM8ingMMQQ" id="(0.15079365079365079,0.12376237623762376)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_unpjgNIXEeKovM8ingMMQQ" type="4001" source="_iSAZUNITEeKovM8ingMMQQ" target="_thQYoNIWEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_unpjg9IXEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_unpjhNIXEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_unpjhdIXEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_unpjhtIXEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_unpjh9IXEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_unpjiNIXEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_unvqINIXEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_unvqIdIXEeKovM8ingMMQQ" x="37" y="16"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_unvqItIXEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_unvqI9IXEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_unvqJNIXEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_unvqJdIXEeKovM8ingMMQQ" x="49" y="-14"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_unpjgdIXEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_unRJANIXEeKovM8ingMMQQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_unpjgtIXEeKovM8ingMMQQ" points="[8, 0, -212, -276]$[85, 0, -135, -276]$[85, 284, -135, 8]$[211, 284, -9, 8]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_un1wwNIXEeKovM8ingMMQQ" id="(0.9820224719101124,0.9603960396039604)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_un1wwdIXEeKovM8ingMMQQ" id="(0.09,0.1)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_d40j0NIZEeKovM8ingMMQQ" type="4001" source="_iSAZUNITEeKovM8ingMMQQ" target="_vQqgwNIWEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_d40j09IZEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_d40j1NIZEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_d40j1dIZEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_d40j1tIZEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_d40j19IZEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_d40j2NIZEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_d40j2dIZEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_d40j2tIZEeKovM8ingMMQQ" x="-33" y="12"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_d40j29IZEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_d46qcNIZEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_d46qcdIZEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_d46qctIZEeKovM8ingMMQQ" x="-1" y="-12"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_d40j0dIZEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_PYgEENIQEeKovM8ingMMQQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_d40j0tIZEeKovM8ingMMQQ" points="[156, -180, -306, 355]$[399, -462, -63, 73]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_hVHEgNIZEeKovM8ingMMQQ" id="(0.952808988764045,0.6547085201793722)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_h1OvANIZEeKovM8ingMMQQ" id="(0.1349206349206349,0.31297709923664124)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_fRQWYNIZEeKovM8ingMMQQ" type="4001" source="_nf1owNIWEeKovM8ingMMQQ" target="_vQqgwNIWEeKovM8ingMMQQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_fRcjoNIZEeKovM8ingMMQQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_fRcjodIZEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_fRcjotIZEeKovM8ingMMQQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_fRcjo9IZEeKovM8ingMMQQ" x="28" y="76"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_fRcjpNIZEeKovM8ingMMQQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_fRcjpdIZEeKovM8ingMMQQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_fRcjptIZEeKovM8ingMMQQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_fRcjp9IZEeKovM8ingMMQQ" y="51"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_fRcjqNIZEeKovM8ingMMQQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_fRcjqdIZEeKovM8ingMMQQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_fRcjqtIZEeKovM8ingMMQQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_fRcjq9IZEeKovM8ingMMQQ" x="30" y="30"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_fRQWYdIZEeKovM8ingMMQQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#__8-UwNIQEeKovM8ingMMQQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_fRQWYtIZEeKovM8ingMMQQ" points="[11, 0, -254, 365]$[142, 0, -123, 365]$[142, -358, -123, 7]$[202, -358, -63, 7]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qZLtENIZEeKovM8ingMMQQ" id="(0.9734939759036144,0.027700831024930747)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_EvbecNLSEeKwWoA8j13SIg" type="PapyrusUMLClassDiagram" name="oneListener" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_FqVAcNLSEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_FqVActLSEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_FqVAc9LSEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_FqbHENLSEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_FqbHEdLSEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_FqbHEtLSEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_FqbHE9LSEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_FqbHFNLSEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_FqbHFdLSEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_FqbHFtLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_FqbHF9LSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_FqbHGNLSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_FqbHGdLSEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_FqbHGtLSEeKwWoA8j13SIg" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_aLsWQNLTEeKwWoA8j13SIg" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#___ERUNLSEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_aLsWQdLTEeKwWoA8j13SIg"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_aLsWQtLTEeKwWoA8j13SIg" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_OXuY8NLTEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_aLsWQ9LTEeKwWoA8j13SIg"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_aLsWRNLTEeKwWoA8j13SIg" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_c-YVwNLSEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_aLsWRdLTEeKwWoA8j13SIg"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_f8tSoNLTEeKwWoA8j13SIg" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_dAOTYNLTEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_f8tSodLTEeKwWoA8j13SIg" x="70" y="66"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_FqbHG9LSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_FqbHHNLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_FqbHHdLSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_FqbHHtLSEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_FqbHH9LSEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_FqbHINLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_FqbHIdLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_FqbHItLSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_FqbHI9LSEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_FpeE0NLSEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_FqVAcdLSEeKwWoA8j13SIg" x="48" y="192"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_MF58wNLSEeKwWoA8j13SIg" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_MF6j0NLSEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_MF6j0dLSEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_MF7K4NLSEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_MF7K4dLSEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_MF7K4tLSEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_MF7K49LSEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_MF7K5NLSEeKwWoA8j13SIg" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_MF7K5dLSEeKwWoA8j13SIg" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_MF7K5tLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_MF7K59LSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_MF7K6NLSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_MF7K6dLSEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_MF7x8NLSEeKwWoA8j13SIg" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_-M6XMNLSEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_7UNrwNLSEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_-M6XMdLSEeKwWoA8j13SIg" x="95" y="5"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_lHhKoNLTEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_hnQI4NLTEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_lHhKodLTEeKwWoA8j13SIg" x="68" y="28"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_MF7x8dLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_MF7x8tLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_MF7x89LSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_MF7x9NLSEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_MF7x9dLSEeKwWoA8j13SIg" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_MF7x9tLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_MF7x99LSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_MF7x-NLSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_MF7x-dLSEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_MFiwYNLSEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_MF58wdLSEeKwWoA8j13SIg" x="306" y="12"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_TqP38NLSEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_TqP38tLSEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_TqV-kNLSEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_TqV-kdLSEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_TqV-ktLSEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_TqV-k9LSEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_TqV-lNLSEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_TqV-ldLSEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_TqV-ltLSEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_TqV-l9LSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_TqV-mNLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_TqV-mdLSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_TqV-mtLSEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_TqV-m9LSEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_TqV-nNLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_TqV-ndLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_TqV-ntLSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_TqV-n9LSEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_TqV-oNLSEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_TqV-odLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_TqV-otLSEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_TqV-o9LSEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_TqV-pNLSEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_TqDqsNLSEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_TqP38dLSEeKwWoA8j13SIg" x="510" y="192" width="128"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_1RgtANLTEeKwWoA8j13SIg" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1RgtAtLTEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1RgtA9LTEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1RgtBNLTEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1RgtBdLTEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1RgtBtLTEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1RgtB9LTEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_1RgtCNLTEeKwWoA8j13SIg" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_1Q1-oNLTEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_1RgtAdLTEeKwWoA8j13SIg" x="564" y="324"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_EvbecdLSEeKwWoA8j13SIg"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_93lc4NLREeKwWoA8j13SIg"/>
+    <edges xmi:type="notation:Connector" xmi:id="_qQ-0QNLSEeKwWoA8j13SIg" type="4001" source="_FqVAcNLSEeKwWoA8j13SIg" target="_MF58wNLSEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_qQ-0Q9LSEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qQ-0RNLSEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qQ-0RdLSEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qQ-0RtLSEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qQ-0R9LSEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qQ-0SNLSEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qRE64NLSEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qRE64dLSEeKwWoA8j13SIg" x="-26" y="19"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qRE64tLSEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qRE649LSEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qRE65NLSEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qRE65dLSEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_qQ-0QdLSEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_qQmZwNLSEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_qQ-0QtLSEeKwWoA8j13SIg" points="[0, -3, -172, 128]$[0, -131, -172, 0]$[159, -131, -13, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qRRIINLSEeKwWoA8j13SIg" id="(0.24815724815724816,0.06707317073170732)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qRRIIdLSEeKwWoA8j13SIg" id="(0.08024691358024691,0.46017699115044247)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_vmTdsNLTEeKwWoA8j13SIg" type="4008" source="_FqVAcNLSEeKwWoA8j13SIg" target="_TqP38NLSEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_vmTds9LTEeKwWoA8j13SIg" visible="false" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vmZkUNLTEeKwWoA8j13SIg" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vmZkUdLTEeKwWoA8j13SIg" visible="false" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vmZkUtLTEeKwWoA8j13SIg" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_vmTdsdLTEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_vlovUNLTEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_vmTdstLTEeKwWoA8j13SIg" points="[11, -6, -65, 0]$[66, -7, -10, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_vmfq8NLTEeKwWoA8j13SIg" id="(0.972972972972973,0.31097560975609756)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_vmfq8dLTEeKwWoA8j13SIg" id="(0.078125,0.45)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_wTabUNLTEeKwWoA8j13SIg" type="4008" source="_MF58wNLSEeKwWoA8j13SIg" target="_TqP38NLSEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_wTabU9LTEeKwWoA8j13SIg" visible="false" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_wTabVNLTEeKwWoA8j13SIg" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_wTabVdLTEeKwWoA8j13SIg" visible="false" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_wTabVtLTEeKwWoA8j13SIg" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_wTabUdLTEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_wSvs8NLTEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_wTabUtLTEeKwWoA8j13SIg" points="[3, 8, -25, -51]$[13, 44, -15, -15]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_wTgh8NLTEeKwWoA8j13SIg" id="(0.911504424778761,0.9444444444444444)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_wTgh8dLTEeKwWoA8j13SIg" id="(0.234375,0.15)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_-hv_gNNmEeKwWoA8j13SIg" type="PapyrusUMLClassDiagram" name="Service" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_BZJqcNNnEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BZJqctNnEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BZJqc9NnEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BZJqdNNnEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BZJqddNnEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BZJqdtNnEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BZJqd9NnEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_BZJqeNNnEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BZJqedNnEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BZJqetNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BZJqe9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BZJqfNNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BZJqfdNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BZJqftNnEeKwWoA8j13SIg" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_86teUNNoEeKwWoA8j13SIg" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_86bKcNNoEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_86teUdNoEeKwWoA8j13SIg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BZJqf9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BZJqgNNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BZJqgdNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BZJqgtNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BZJqg9NnEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BZJqhNNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BZJqhdNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BZJqhtNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BZJqh9NnEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_BY3WkNNnEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BZJqcdNnEeKwWoA8j13SIg" x="24" y="216" width="213" height="301"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_LrtfYNNnEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LrzmANNnEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LrzmAdNnEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LrzmAtNnEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LrzmA9NnEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LrzmBNNnEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LrzmBdNnEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_LrzmBtNnEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LrzmB9NnEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LrzmCNNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LrzmCdNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LrzmCtNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LrzmC9NnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LrzmDNNnEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LrzmDdNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LrzmDtNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LrzmD9NnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LrzmENNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LrzmEdNnEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LrzmEtNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LrzmE9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LrzmFNNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LrzmFdNnEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_LrbLgNNnEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LrtfYdNnEeKwWoA8j13SIg" x="743" y="217" width="163" height="145"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_QDgmENNnEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QDmssNNnEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_QDmssdNnEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QDmsstNnEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_QDmss9NnEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QDmstNNnEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_QDmstdNnEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_QDmsttNnEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_QDszUNNnEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_QDszUdNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_QDszUtNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_QDszU9NnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QDszVNNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_QDszVdNnEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_QDszVtNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_QDszV9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_QDszWNNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QDszWdNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_QDszWtNnEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_QDszW9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_QDszXNNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_QDszXdNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QDszXtNnEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rqknoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QDgmEdNnEeKwWoA8j13SIg" x="1008" y="144"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_TCnbgNNnEeKwWoA8j13SIg" type="2007" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_TCnbgtNnEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_TCnbg9NnEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_TCnbhNNnEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_TCnbhdNnEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_TCtiINNnEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_TCtiIdNnEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_TCtiItNnEeKwWoA8j13SIg" type="5026"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_TCtiI9NnEeKwWoA8j13SIg" type="7016">
+        <children xmi:type="notation:Shape" xmi:id="_PInZMNNpEeKwWoA8j13SIg" type="3010" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PInZMtNpEeKwWoA8j13SIg" source="ShadowFigure">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PInZM9NpEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PInZNNNpEeKwWoA8j13SIg" source="displayNameLabelIcon">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PInZNdNpEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PInZNtNpEeKwWoA8j13SIg" source="QualifiedName">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PInZN9NpEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+          </eAnnotations>
+          <children xmi:type="notation:DecorationNode" xmi:id="_PInZONNpEeKwWoA8j13SIg" type="5014"/>
+          <children xmi:type="notation:BasicCompartment" xmi:id="_PInZOdNpEeKwWoA8j13SIg" type="7011">
+            <styles xmi:type="notation:TitleStyle" xmi:id="_PInZOtNpEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:SortingStyle" xmi:id="_PInZO9NpEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:FilteringStyle" xmi:id="_PInZPNNpEeKwWoA8j13SIg"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PInZPdNpEeKwWoA8j13SIg"/>
+          </children>
+          <children xmi:type="notation:BasicCompartment" xmi:id="_PInZPtNpEeKwWoA8j13SIg" type="7012">
+            <styles xmi:type="notation:TitleStyle" xmi:id="_PInZP9NpEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:SortingStyle" xmi:id="_PInZQNNpEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:FilteringStyle" xmi:id="_PInZQdNpEeKwWoA8j13SIg"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PInZQtNpEeKwWoA8j13SIg"/>
+          </children>
+          <children xmi:type="notation:BasicCompartment" xmi:id="_PInZQ9NpEeKwWoA8j13SIg" type="7013">
+            <styles xmi:type="notation:TitleStyle" xmi:id="_PInZRNNpEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:SortingStyle" xmi:id="_PInZRdNpEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:FilteringStyle" xmi:id="_PInZRtNpEeKwWoA8j13SIg"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PInZR9NpEeKwWoA8j13SIg"/>
+          </children>
+          <element xmi:type="uml:Class" href="architecture-v3.uml#_3qy5UNNnEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PInZMdNpEeKwWoA8j13SIg" x="57" y="29"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_RAaTMNNnEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_RAaTMtNnEeKwWoA8j13SIg" source="ShadowFigure">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_RAaTM9NnEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_RAaTNNNnEeKwWoA8j13SIg" source="displayNameLabelIcon">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_RAaTNdNnEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_RAaTNtNnEeKwWoA8j13SIg" source="QualifiedName">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_RAaTN9NnEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+          </eAnnotations>
+          <children xmi:type="notation:DecorationNode" xmi:id="_RAaTONNnEeKwWoA8j13SIg" type="5029"/>
+          <children xmi:type="notation:BasicCompartment" xmi:id="_RAaTOdNnEeKwWoA8j13SIg" type="7017">
+            <styles xmi:type="notation:TitleStyle" xmi:id="_RAaTOtNnEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:SortingStyle" xmi:id="_RAaTO9NnEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:FilteringStyle" xmi:id="_RAaTPNNnEeKwWoA8j13SIg"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_RAaTPdNnEeKwWoA8j13SIg"/>
+          </children>
+          <children xmi:type="notation:BasicCompartment" xmi:id="_RAaTPtNnEeKwWoA8j13SIg" type="7018">
+            <styles xmi:type="notation:TitleStyle" xmi:id="_RAaTP9NnEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:SortingStyle" xmi:id="_RAaTQNNnEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:FilteringStyle" xmi:id="_RAaTQdNnEeKwWoA8j13SIg"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_RAaTQtNnEeKwWoA8j13SIg"/>
+          </children>
+          <children xmi:type="notation:BasicCompartment" xmi:id="_RAaTQ9NnEeKwWoA8j13SIg" type="7019">
+            <styles xmi:type="notation:TitleStyle" xmi:id="_RAaTRNNnEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:SortingStyle" xmi:id="_RAaTRdNnEeKwWoA8j13SIg"/>
+            <styles xmi:type="notation:FilteringStyle" xmi:id="_RAaTRtNnEeKwWoA8j13SIg"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_RAaTR9NnEeKwWoA8j13SIg"/>
+          </children>
+          <element xmi:type="uml:Class" href="architecture-v3.uml#_t0NNoM9UEeKO_rl5MA6s9A"/>
+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_RAaTMdNnEeKwWoA8j13SIg" x="655" y="13" height="121"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_TCtiJNNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_TCtiJdNnEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Package" href="architecture-v3.uml#_KxbdELZKEeK8zaQi-hvdlw"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_TCnbgdNnEeKwWoA8j13SIg" x="348" y="486" width="859" height="187"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_Xlp28NNpEeKwWoA8j13SIg" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Xlp28tNpEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Xlp289NpEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Xlp29NNpEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Xlp29dNpEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Xlp29tNpEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Xlp299NpEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Xlp2-NNpEeKwWoA8j13SIg" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Xlp2-dNpEeKwWoA8j13SIg" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Xlp2-tNpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Xlp2-9NpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Xlp2_NNpEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xlp2_dNpEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Xlp2_tNpEeKwWoA8j13SIg" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_bdww8NNpEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_bdkjsNNpEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_bdww8dNpEeKwWoA8j13SIg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Xlp2_9NpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Xlp3ANNpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Xlp3AdNpEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xlp3AtNpEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Xlp3A9NpEeKwWoA8j13SIg" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Xlp3BNNpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Xlp3BdNpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Xlp3BtNpEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xlp3B9NpEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_XlXjENNpEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xlp28dNpEeKwWoA8j13SIg" x="30" y="36" width="245"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_T7YuEEyeEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_T7ZVIEyeEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_T7ZVIUyeEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_T7Z8MEyeEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_T7Z8MUyeEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_T7Z8MkyeEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_T7Z8M0yeEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_T7Z8NEyeEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_T7ajQEyeEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_T7ajQUyeEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_T7ajQkyeEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_T7ajQ0yeEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_T7ajREyeEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_T7ajRUyeEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_T7ajRkyeEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_T7ajR0yeEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_T7ajSEyeEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_T7ajSUyeEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_T7ajSkyeEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_T7ajS0yeEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_T7ajTEyeEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_T7ajTUyeEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_T7ajTkyeEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_T7VDsEyeEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_T7YuEUyeEeObF6ELIGKT-g" x="366" y="234" width="247"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_VLl8QEyfEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_VLmjUEyfEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_VLnKYEyfEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_VLnKYUyfEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_VLnKYkyfEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_VLnxcEyfEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_VLnxcUyfEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VLnxckyfEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_VLnxc0yfEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_VLnxdEyfEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_VLnxdUyfEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_VLnxdkyfEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_VLnxd0yfEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_VLoYgEyfEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_VLoYgUyfEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_VLoYgkyfEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_VLoYg0yfEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_VLoYhEyfEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_VLoYhUyfEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_VLoYhkyfEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_VLoYh0yfEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_VLoYiEyfEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_VLoYiUyfEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_z8UwcEydEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_VLl8QUyfEeObF6ELIGKT-g" x="732" y="384" width="193"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_-hv_gdNmEeKwWoA8j13SIg"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_IygSQLZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_UfawsNNnEeKwWoA8j13SIg" type="4001" source="_T7YuEEyeEeObF6ELIGKT-g" target="_LrtfYNNnEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ufaws9NnEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_UfawtNNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_UfawtdNnEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_UfawttNnEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ufawt9NnEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_UfawuNNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_UfawudNnEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_UfawutNnEeKwWoA8j13SIg" x="-35" y="15"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ufawu9NnEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_UfawvNNnEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_UfawvdNnEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_UfawvtNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_UfawsdNnEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_UfCWMNNnEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_UfawstNnEeKwWoA8j13SIg" points="[9, -3, -126, 0]$[132, -4, -3, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Ufm98NNnEeKwWoA8j13SIg" id="(0.805668016194332,0.44)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Ufm98dNnEeKwWoA8j13SIg" id="(0.01935483870967742,0.42)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_VYUHkNNnEeKwWoA8j13SIg" type="4001" source="_LrtfYNNnEeKwWoA8j13SIg" target="_QDgmENNnEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_VYUHk9NnEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VYUHlNNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VYUHldNnEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VYUHltNnEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VYUHl9NnEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VYUHmNNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VYUHmdNnEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VYUHmtNnEeKwWoA8j13SIg" x="-26" y="23"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VYUHm9NnEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VYUHnNNnEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VYUHndNnEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VYUHntNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_VYUHkdNnEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_VX7tENNnEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_VYUHktNnEeKwWoA8j13SIg" points="[4, 3, -111, 0]$[114, 3, -1, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_VYaOMNNnEeKwWoA8j13SIg" id="(0.9741935483870968,0.14)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_VYaOMdNnEeKwWoA8j13SIg" id="(0.01,0.9)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_WY-TUNNnEeKwWoA8j13SIg" type="4001" source="_LrtfYNNnEeKwWoA8j13SIg" target="_RAaTMNNnEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_WY-TU9NnEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WY-TVNNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WY-TVdNnEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WY-TVtNnEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WY-TV9NnEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WY-TWNNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WY-TWdNnEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WY-TWtNnEeKwWoA8j13SIg" x="-22" y="24"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WY-TW9NnEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WY-TXNNnEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WY-TXdNnEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WY-TXtNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_WY-TUdNnEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_WYl40NNnEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_WY-TUtNnEeKwWoA8j13SIg" points="[3, 0, -115, -211]$[118, 0, 0, -211]$[118, 209, 0, -2]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_WZKgkNNnEeKwWoA8j13SIg" id="(0.9815950920245399,0.7241379310344828)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_WZKgkdNnEeKwWoA8j13SIg" id="(0.13,0.01652892561983471)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_g6_EENNoEeKwWoA8j13SIg" type="4001" source="_RAaTMNNnEeKwWoA8j13SIg" target="_QDgmENNnEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_g6_EE9NoEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_g6_EFNNoEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_g6_EFdNoEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_g6_EFtNoEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_g7FKsNNoEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_g7FKsdNoEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_g7FKstNoEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_g7FKs9NoEeKwWoA8j13SIg" x="2" y="46"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_g7FKtNNoEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_g7FKtdNoEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_g7FKttNoEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_g7FKt9NoEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_g6_EEdNoEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_3h0tAM9VEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_g6_EEtNoEeKwWoA8j13SIg" points="[-5, -60, 0, 149]$[0, -159, 5, 50]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_g_de8NNpEeKwWoA8j13SIg" type="4003" source="_BZJqcNNnEeKwWoA8j13SIg" target="_Xlp28NNpEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_g_de89NpEeKwWoA8j13SIg" visible="false" type="6008">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_g_de9NNpEeKwWoA8j13SIg" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_g_de9dNpEeKwWoA8j13SIg" visible="false" type="6009">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_g_de9tNpEeKwWoA8j13SIg" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_g_de8dNpEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:InterfaceRealization" href="architecture-v3.uml#_g-43MNNpEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_g_de8tNpEeKwWoA8j13SIg" points="[2, -9, -14, 59]$[11, -53, -5, 15]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_g_vy0NNpEeKwWoA8j13SIg" id="(0.4647887323943662,0.06474820143884892)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_g_vy0dNpEeKwWoA8j13SIg" id="(0.3836734693877551,0.9838709677419355)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_qANtwNNpEeKwWoA8j13SIg" type="4001" source="_BZJqcNNnEeKwWoA8j13SIg" target="_PInZMNNpEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_qAOU0NNpEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qAOU0dNpEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qAO74NNpEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qAO74dNpEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qAO74tNpEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qAO749NpEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qAO75NNpEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qAO75dNpEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qAPi8NNpEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qAPi8dNpEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qAPi8tNpEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_qAPi89NpEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_qANtwdNpEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_p_wawNNpEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_qANtwtNpEeKwWoA8j13SIg" points="[0, 22, -224, -67]$[0, 89, -224, 0]$[218, 89, -6, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qAWQoNNpEeKwWoA8j13SIg" id="(0.7887323943661971,0.9280575539568345)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_qAWQodNpEeKwWoA8j13SIg" id="(0.06,0.37)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_9O-LEEyeEeObF6ELIGKT-g" type="4001" source="_BZJqcNNnEeKwWoA8j13SIg" target="_T7YuEEyeEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_9O-yIEyeEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9O-yIUyeEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9O-yIkyeEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9O-yI0yeEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9O-yJEyeEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9O-yJUyeEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9O-yJkyeEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9O-yJ0yeEeObF6ELIGKT-g" x="-25" y="21"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9O-yKEyeEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9O-yKUyeEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9O_ZMEyeEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9O_ZMUyeEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_9O-LEUyeEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_9O7u0EyeEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_9O-LEkyeEeObF6ELIGKT-g" points="[6, -6, -135, 0]$[135, -7, -6, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_9PGt8EyeEeObF6ELIGKT-g" id="(0.9577464788732394,0.19269102990033224)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_9PHVAEyeEeObF6ELIGKT-g" id="(0.024291497975708502,0.37)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_mrloQEyfEeObF6ELIGKT-g" type="4001" source="_T7YuEEyeEeObF6ELIGKT-g" target="_VLl8QEyfEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_mrndcEyfEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mrndcUyfEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mrndckyfEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mroEgEyfEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mroEgUyfEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mroEgkyfEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mrorkEyfEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mrorkUyfEeObF6ELIGKT-g" x="-31" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mrorkkyfEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mrork0yfEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mrpSoEyfEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_mrpSoUyfEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_mrloQUyfEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_mrhW0EyfEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_mrloQkyfEeObF6ELIGKT-g" points="[0, 4, -153, -88]$[0, 92, -153, 0]$[152, 92, -1, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_msFXgEyfEeObF6ELIGKT-g" id="(0.8663967611336032,0.96)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_msFXgUyfEeObF6ELIGKT-g" id="(0.0051813471502590676,0.38)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_12QZkNNnEeKwWoA8j13SIg" type="PapyrusUMLClassDiagram" name="layer model" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_3A1WUNNnEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_3A1WUtNnEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_3A1WU9NnEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_3A1WVNNnEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_3A1WVdNnEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_3A1WVtNnEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_3A1WV9NnEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3A1WWNNnEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_3A1WWdNnEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_3A1WWtNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_3A1WW9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_3A1WXNNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_3A1WXdNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_3A1WXtNnEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_3A1WX9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_3A1WYNNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_3A1WYdNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_3A1WYtNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_3A1WY9NnEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_3A1WZNNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_3A1WZdNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_3A1WZtNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_3A1WZ9NnEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_t0NNoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_3A1WUdNnEeKwWoA8j13SIg" x="336" y="264"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_3rLT0NNnEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_3rLT0tNnEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_3rLT09NnEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_3rLT1NNnEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_3rRacNNnEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_3rRacdNnEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_3rRactNnEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_3rRac9NnEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_3rRadNNnEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_3rRaddNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_3rRadtNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_3rRad9NnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_3rRaeNNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_3rRaedNnEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_3rRaetNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_3rRae9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_3rRafNNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_3rRafdNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_3rRaftNnEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_3rRaf9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_3rRagNNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_3rRagdNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_3rRagtNnEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_3qy5UNNnEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_3rLT0dNnEeKwWoA8j13SIg" x="93" y="265"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_5s4s4NNnEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_5s-zgNNnEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_5s-zgdNnEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_5s-zgtNnEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_5s-zg9NnEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_5s-zhNNnEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_5s-zhdNnEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_5s-zhtNnEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_5s-zh9NnEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_5s-ziNNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_5s-zidNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_5s-zitNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_5s-zi9NnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_5s-zjNNnEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_5s-zjdNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_5s-zjtNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_5s-zj9NnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_5s-zkNNnEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_5s-zkdNnEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_5s-zktNnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_5s-zk9NnEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_5s-zlNNnEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_5s-zldNnEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rqknoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_5s4s4dNnEeKwWoA8j13SIg" x="336" y="96"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_QvnosNNoEeKwWoA8j13SIg" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QvnostNoEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Qvnos9NoEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QvnotNNoEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_QvnotdNoEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QvnottNoEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Qvnot9NoEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_QvnouNNoEeKwWoA8j13SIg" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_QvVU0NNoEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QvnosdNoEeKwWoA8j13SIg" x="18" y="96" width="235" height="115"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_iO2pQNN0EeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iO3QUNN0EeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iO33YNN0EeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iO33YdN0EeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iO33YtN0EeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iO33Y9N0EeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iO33ZNN0EeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_iO33ZdN0EeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iO33ZtN0EeKwWoA8j13SIg" type="7017">
+        <children xmi:type="notation:Shape" xmi:id="_zPijENN0EeKwWoA8j13SIg" type="3012" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_zPQPMNN0EeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_zPijEdN0EeKwWoA8j13SIg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iO33Z9N0EeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iO33aNN0EeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iO33adN0EeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iO33atN0EeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iO4ecNN0EeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iO4ecdN0EeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iO4ectN0EeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iO4ec9N0EeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iO4edNN0EeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iO4eddN0EeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iO4edtN0EeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iO4ed9N0EeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iO4eeNN0EeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iO4eedN0EeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_iOVr4NN0EeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iO2pQdN0EeKwWoA8j13SIg" x="306" y="468" width="187"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_Rks4wNN3EeKwWoA8j13SIg" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Rks4wtN3EeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Rks4w9N3EeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Rks4xNN3EeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Rks4xdN3EeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Rks4xtN3EeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Rks4x9N3EeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Rks4yNN3EeKwWoA8j13SIg" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_Rkak4NN3EeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Rks4wdN3EeKwWoA8j13SIg" x="504" y="456" width="231" height="178"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_12QZkdNnEeKwWoA8j13SIg"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_KxbdELZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_8_iwcNNnEeKwWoA8j13SIg" type="4001" source="_3rLT0NNnEeKwWoA8j13SIg" target="_3A1WUNNnEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_8_iwc9NnEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8_iwdNNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_8_iwddNnEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8_iwdtNnEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_8_iwd9NnEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8_iweNNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_8_iwedNnEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8_iwetNnEeKwWoA8j13SIg" x="-35" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_8_iwe9NnEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8_iwfNNnEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_8_iwfdNnEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8_iwftNnEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_8_iwcdNnEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_8_KV8NNnEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_8_iwctNnEeKwWoA8j13SIg" points="[10, 4, -151, 0]$[153, 1, -8, -3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_8_o3ENNnEeKwWoA8j13SIg" id="(0.9,0.33)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_8_o3EdNnEeKwWoA8j13SIg" id="(0.08,0.38)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_I4D2kNNoEeKwWoA8j13SIg" type="4001" source="_3A1WUNNnEeKwWoA8j13SIg" target="_5s4s4NNnEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_I4D2k9NoEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I4D2lNNoEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I4D2ldNoEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I4D2ltNoEeKwWoA8j13SIg" x="10" y="-50"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I4D2l9NoEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I4D2mNNoEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I4D2mdNoEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I4D2mtNoEeKwWoA8j13SIg" x="-8" y="47"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I4D2m9NoEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I4D2nNNoEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I4D2ndNoEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I4D2ntNoEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_I4D2kdNoEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_3h0tAM9VEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_I4D2ktNoEeKwWoA8j13SIg" points="[0, -50, 0, 118]$[0, -80, 0, 88]$[0, -118, 0, 50]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_4CYnANN0EeKwWoA8j13SIg" type="4001" source="_3A1WUNNnEeKwWoA8j13SIg" target="_iO2pQNN0EeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_4CetoNN0EeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_4CetodN0EeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_4CetotN0EeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_4Ceto9N0EeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_4CetpNN0EeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_4CetpdN0EeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_4CetptN0EeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_4Cetp9N0EeKwWoA8j13SIg" x="-10" y="75"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_4CetqNN0EeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_4CetqdN0EeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_4CetqtN0EeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_4Cetq9N0EeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_4CYnAdN0EeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_4CAMgNN0EeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_4CYnAtN0EeKwWoA8j13SIg" points="[7, 6, 0, -106]$[6, 110, -1, -2]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_4Ck0QNN0EeKwWoA8j13SIg" id="(0.4,0.94)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_4Ck0QdN0EeKwWoA8j13SIg" id="(0.4117647058823529,0.019230769230769232)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_3zc0INNpEeKwWoA8j13SIg" type="PapyrusUMLClassDiagram" name="LayerStackSynchronizer" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="__potQNNpEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__potQtNpEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="__potQ9NpEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__potRNNpEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="__potRdNpEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__potRtNpEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="__potR9NpEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="__potSNNpEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="__potSdNpEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="__potStNpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="__potS9NpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="__potTNNpEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="__potTdNpEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="__potTtNpEeKwWoA8j13SIg" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_pEqZkNNrEeKwWoA8j13SIg" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_pEYFsNNrEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_pEqZkdNrEeKwWoA8j13SIg"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_qCq58NNrEeKwWoA8j13SIg" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_qCessNNrEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_qCq58dNrEeKwWoA8j13SIg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="__potT9NpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="__potUNNpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="__potUdNpEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="__potUtNpEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="__potU9NpEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="__potVNNpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="__potVdNpEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="__potVtNpEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="__potV9NpEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_LrbLgNNnEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="__potQdNpEeKwWoA8j13SIg" x="233" y="228" width="247" height="385"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_AhdtINNqEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_AheUMNNqEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_AheUMdNqEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Ahe7QNNqEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Ahe7QdNqEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Ahe7QtNqEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Ahe7Q9NqEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ahe7RNNqEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Ahe7RdNqEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Ahe7RtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Ahe7R9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Ahe7SNNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Ahe7SdNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_AhfiUNNqEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_AhfiUdNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_AhfiUtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_AhfiU9NqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AhfiVNNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_AhfiVdNqEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_AhfiVtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_AhfiV9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_AhfiWNNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AhfiWdNqEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rqknoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AhdtIdNqEeKwWoA8j13SIg" x="-13" y="384"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_BPtTMNNqEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BPt6QNNqEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BPt6QdNqEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BPuhUNNqEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BPuhUdNqEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BPuhUtNqEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BPuhU9NqEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_BPuhVNNqEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BPuhVdNqEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BPuhVtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BPuhV9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BPuhWNNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BPuhWdNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BPvIYNNqEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BPvIYdNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BPvIYtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BPvIY9NqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BPvIZNNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BPvIZdNqEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BPvIZtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BPvIZ9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BPvIaNNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BPvIadNqEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_t0NNoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BPtTMdNqEeKwWoA8j13SIg" x="725" y="372"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_HJqJINNqEeKwWoA8j13SIg" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_HJqJItNqEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_HJqJI9NqEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_HJqJJNNqEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_HJqJJdNqEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_HJqJJtNqEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_HJqJJ9NqEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_HJqJKNNqEeKwWoA8j13SIg" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_HJqJKdNqEeKwWoA8j13SIg" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_HJqJKtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_HJqJK9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_HJqJLNNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_HJqJLdNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_HJqJLtNqEeKwWoA8j13SIg" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_JaHv4NNqEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_JZ7ioNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_JaHv4dNqEeKwWoA8j13SIg"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_PskVQN9mEeKCZbxNW-U3VQ" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_Ft6TwN9mEeKCZbxNW-U3VQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_PskVQd9mEeKCZbxNW-U3VQ" x="77" y="27"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_HJqJL9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_HJqJMNNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_HJqJMdNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_HJqJMtNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_HJqJM9NqEeKwWoA8j13SIg" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_HJqJNNNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_HJqJNdNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_HJqJNtNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_HJqJN9NqEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_HJLoANNqEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_HJqJIdNqEeKwWoA8j13SIg" x="12" y="-66"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_OTRQINNqEeKwWoA8j13SIg" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_OTRQItNqEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_OTRQI9NqEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_OTRQJNNqEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_OTRQJdNqEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_OTRQJtNqEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_OTRQJ9NqEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_OTRQKNNqEeKwWoA8j13SIg" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_OTRQKdNqEeKwWoA8j13SIg" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_OTRQKtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_OTRQK9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_OTRQLNNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OTRQLdNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_OTRQLtNqEeKwWoA8j13SIg" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_SmxFoNNqEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_SmexwNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_SmxFodNqEeKwWoA8j13SIg"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_KdsQQNNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_htRxwNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Kds3UNNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Kdxv0NNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_h5JDgNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Kdxv0dNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Kd0MENNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_h69BYNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Kd0MEdNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Kd3PYNNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_iGe78NNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Kd3PYdNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Kd5roNNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_iKn1ENNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Kd6SsNNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Kd8u8NNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_iUNO4NNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Kd8u8dNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Kd_LMNNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_1WChENNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Kd_LMdNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_KeCOgNNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_1iV3sNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_KeCOgdNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_KeEqwNNrEeKwWoA8j13SIg" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_1mcUkNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_KeFR0NNrEeKwWoA8j13SIg" x="214" y="23"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_EGTcwN9mEeKCZbxNW-U3VQ" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_94G1IN9lEeKCZbxNW-U3VQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_EGTcwd9mEeKCZbxNW-U3VQ" x="85" y="197"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_OTRQL9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_OTRQMNNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_OTRQMdNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OTRQMtNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_OTRQM9NqEeKwWoA8j13SIg" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_OTRQNNNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_OTRQNdNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_OTRQNtNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OTRQN9NqEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_OS41oNNqEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OTRQIdNqEeKwWoA8j13SIg" x="510" y="-204" width="247"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_Xb96ANNqEeKwWoA8j13SIg" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Xb96AtNqEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Xb96A9NqEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Xb96BNNqEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Xb96BdNqEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Xb96BtNqEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Xb96B9NqEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Xb96CNNqEeKwWoA8j13SIg" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Xb96CdNqEeKwWoA8j13SIg" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Xb96CtNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Xb96C9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Xb96DNNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xb96DdNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Xb96DtNqEeKwWoA8j13SIg" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Xb96D9NqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Xb96ENNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Xb96EdNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xb96EtNqEeKwWoA8j13SIg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Xb96E9NqEeKwWoA8j13SIg" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Xb96FNNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Xb96FdNqEeKwWoA8j13SIg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Xb96FtNqEeKwWoA8j13SIg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xb96F9NqEeKwWoA8j13SIg"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_XbvQgNNqEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xb96AdNqEeKwWoA8j13SIg" x="816" y="-138"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_z1aUcNNtEeKwWoA8j13SIg" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_z1aUctNtEeKwWoA8j13SIg" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_z1aUc9NtEeKwWoA8j13SIg" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_z1aUdNNtEeKwWoA8j13SIg" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_z1aUddNtEeKwWoA8j13SIg" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_z1aUdtNtEeKwWoA8j13SIg" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_z1aUd9NtEeKwWoA8j13SIg" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_z1aUeNNtEeKwWoA8j13SIg" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_z07zUNNtEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z1aUcdNtEeKwWoA8j13SIg" x="222" y="18" width="271" height="162"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_3zc0IdNpEeKwWoA8j13SIg"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_IygSQLZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_AhosQNNqEeKwWoA8j13SIg" type="4001" source="__potQNNpEeKwWoA8j13SIg" target="_AhdtINNqEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ahp6YNNqEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ahp6YdNqEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ahp6YtNqEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ahp6Y9NqEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_AhqhcNNqEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_AhqhcdNqEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_AhqhctNqEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ahqhc9NqEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_AhqhdNNqEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_AhqhddNqEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_AhqhdtNqEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_AhrIgNNqEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_AhpTUNNqEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_VX7tENNnEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_AhpTUdNqEeKwWoA8j13SIg" points="[-55, -50, 262, 240]$[-317, -290, 0, 0]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_BP4SUNNqEeKwWoA8j13SIg" type="4001" source="__potQNNpEeKwWoA8j13SIg" target="_BPtTMNNqEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_BP5gcNNqEeKwWoA8j13SIg" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_BP5gcdNqEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_BP5gctNqEeKwWoA8j13SIg" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_BP5gc9NqEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_BP5gdNNqEeKwWoA8j13SIg" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_BP5gddNqEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_BP5gdtNqEeKwWoA8j13SIg" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_BP6HgNNqEeKwWoA8j13SIg" x="-33" y="26"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_BP6HgdNqEeKwWoA8j13SIg" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_BP6HgtNqEeKwWoA8j13SIg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_BP6Hg9NqEeKwWoA8j13SIg" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_BP6HhNNqEeKwWoA8j13SIg" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_BP4SUdNqEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_WYl40NNnEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_BP4SUtNqEeKwWoA8j13SIg" points="[-55, -50, 262, 240]$[-317, -290, 0, 0]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_TXneUNNrEeKwWoA8j13SIg" type="4008" source="_OTRQINNqEeKwWoA8j13SIg" target="_BPtTMNNqEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_TXneU9NrEeKwWoA8j13SIg" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_TXneVNNrEeKwWoA8j13SIg" x="-1" y="10"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_TXneVdNrEeKwWoA8j13SIg" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_TXneVtNrEeKwWoA8j13SIg" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_TXneUdNrEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_TW8v8NNrEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_TXneUtNrEeKwWoA8j13SIg" points="[1, 4, -47, -171]$[43, 168, -5, -7]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_TXneV9NrEeKwWoA8j13SIg" id="(0.8623481781376519,0.9868421052631579)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_TXneWNNrEeKwWoA8j13SIg" id="(0.22,0.07)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_XZmGANNrEeKwWoA8j13SIg" type="4008" source="_OTRQINNqEeKwWoA8j13SIg" target="_Xb96ANNqEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_XZmGA9NrEeKwWoA8j13SIg" visible="false" type="6026">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_XZmGBNNrEeKwWoA8j13SIg" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_XZmGBdNrEeKwWoA8j13SIg" visible="false" type="6027">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_XZmGBtNrEeKwWoA8j13SIg" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_XZmGAdNrEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Dependency" href="architecture-v3.uml#_XY1RANNrEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_XZmGAtNrEeKwWoA8j13SIg" points="[16, -7, -53, 0]$[63, -9, -6, -2]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_XZsMoNNrEeKwWoA8j13SIg" id="(0.9352226720647774,0.34539473684210525)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_XZsModNrEeKwWoA8j13SIg" id="(0.049586776859504134,0.38)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_f91X8NNrEeKwWoA8j13SIg" type="4003" source="__potQNNpEeKwWoA8j13SIg" target="_HJqJINNqEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_f91X89NrEeKwWoA8j13SIg" visible="false" type="6008">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_f91X9NNrEeKwWoA8j13SIg" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_f91X9dNrEeKwWoA8j13SIg" visible="false" type="6009">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_f91X9tNrEeKwWoA8j13SIg" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_f91X8dNrEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:InterfaceRealization" href="architecture-v3.uml#_f9KpkNNrEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_f91X8tNrEeKwWoA8j13SIg" points="[-6, -12, 69, 147]$[-68, -152, 7, 7]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_f97ekNNrEeKwWoA8j13SIg" id="(0.06072874493927125,0.03116883116883117)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_f97ekdNrEeKwWoA8j13SIg" id="(0.8733333333333333,0.9435483870967742)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_gzmiUNNrEeKwWoA8j13SIg" type="4003" source="__potQNNpEeKwWoA8j13SIg" target="_OTRQINNqEeKwWoA8j13SIg" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_gzmiU9NrEeKwWoA8j13SIg" visible="false" type="6008">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gzmiVNNrEeKwWoA8j13SIg" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gzmiVdNrEeKwWoA8j13SIg" visible="false" type="6009">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gzmiVtNrEeKwWoA8j13SIg" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_gzmiUdNrEeKwWoA8j13SIg" fontName="Segoe UI"/>
+      <element xmi:type="uml:InterfaceRealization" href="architecture-v3.uml#_gyvmsNNrEeKwWoA8j13SIg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_gzmiUtNrEeKwWoA8j13SIg" points="[11, -7, -57, 35]$[63, -33, -5, 9]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_gzso8NNrEeKwWoA8j13SIg" id="(0.9554655870445344,0.033766233766233764)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_gzso8dNrEeKwWoA8j13SIg" id="(0.20647773279352227,0.9703947368421053)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_TiMgUNRgEeKHbZ6TDsPmrQ" type="PapyrusUMLClassDiagram" name="ext prop" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_WW-VENRgEeKHbZ6TDsPmrQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_WXEbsNRgEeKHbZ6TDsPmrQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_WXEbsdRgEeKHbZ6TDsPmrQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_WXEbstRgEeKHbZ6TDsPmrQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_WXEbs9RgEeKHbZ6TDsPmrQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_WXEbtNRgEeKHbZ6TDsPmrQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_WXEbtdRgEeKHbZ6TDsPmrQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WXEbttRgEeKHbZ6TDsPmrQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WXEbt9RgEeKHbZ6TDsPmrQ" type="7017">
+        <children xmi:type="notation:Shape" xmi:id="_h3P6UNRgEeKHbZ6TDsPmrQ" type="3012" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_h2j90NRgEeKHbZ6TDsPmrQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_h3P6UdRgEeKHbZ6TDsPmrQ"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WXEbuNRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WXEbudRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WXEbutRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WXEbu9RgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WXEbvNRgEeKHbZ6TDsPmrQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WXEbvdRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WXEbvtRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WXEbv9RgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WXEbwNRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WXEbwdRgEeKHbZ6TDsPmrQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WXEbwtRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WXEbw9RgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WXEbxNRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WXEbxdRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_WWBS0NRgEeKHbZ6TDsPmrQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WW-VEdRgEeKHbZ6TDsPmrQ" x="342" y="102"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_XqfycNRgEeKHbZ6TDsPmrQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_XqfyctRgEeKHbZ6TDsPmrQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Xqfyc9RgEeKHbZ6TDsPmrQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_XqfydNRgEeKHbZ6TDsPmrQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_XqfyddRgEeKHbZ6TDsPmrQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_XqfydtRgEeKHbZ6TDsPmrQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Xqfyd9RgEeKHbZ6TDsPmrQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_XqfyeNRgEeKHbZ6TDsPmrQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_XqfyedRgEeKHbZ6TDsPmrQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_XqfyetRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Xqfye9RgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_XqfyfNRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_XqfyfdRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_XqfyftRgEeKHbZ6TDsPmrQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Xqfyf9RgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_XqfygNRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_XqfygdRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_XqfygtRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Xql5ENRgEeKHbZ6TDsPmrQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Xql5EdRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Xql5EtRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Xql5E9RgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Xql5FNRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_XqHX8NRgEeKHbZ6TDsPmrQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_XqfycdRgEeKHbZ6TDsPmrQ" x="582" y="96"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_Y8lscNRgEeKHbZ6TDsPmrQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Y8lsctRgEeKHbZ6TDsPmrQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Y8lsc9RgEeKHbZ6TDsPmrQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Y8lsdNRgEeKHbZ6TDsPmrQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Y8lsddRgEeKHbZ6TDsPmrQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Y8lsdtRgEeKHbZ6TDsPmrQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Y8lsd9RgEeKHbZ6TDsPmrQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Y8lseNRgEeKHbZ6TDsPmrQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Y8lsedRgEeKHbZ6TDsPmrQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Y8lsetRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Y8lse9RgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Y8lsfNRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Y8lsfdRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Y8lsftRgEeKHbZ6TDsPmrQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Y8lsf9RgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Y8lsgNRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Y8lsgdRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Y8lsgtRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Y8lsg9RgEeKHbZ6TDsPmrQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Y8lshNRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Y8lshdRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Y8lshtRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Y8lsh9RgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_Y8NR8NRgEeKHbZ6TDsPmrQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Y8lscdRgEeKHbZ6TDsPmrQ" x="348" y="287"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_dFliINRgEeKHbZ6TDsPmrQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_dFliItRgEeKHbZ6TDsPmrQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_dFliI9RgEeKHbZ6TDsPmrQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_dFliJNRgEeKHbZ6TDsPmrQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_dFliJdRgEeKHbZ6TDsPmrQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_dFliJtRgEeKHbZ6TDsPmrQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_dFliJ9RgEeKHbZ6TDsPmrQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_dFliKNRgEeKHbZ6TDsPmrQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dFliKdRgEeKHbZ6TDsPmrQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dFliKtRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dFliK9RgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dFliLNRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dFliLdRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dFliLtRgEeKHbZ6TDsPmrQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dFliL9RgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dFliMNRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dFliMdRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dFliMtRgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dFliM9RgEeKHbZ6TDsPmrQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dFliNNRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dFliNdRgEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dFliNtRgEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dFliN9RgEeKHbZ6TDsPmrQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_dFTOQNRgEeKHbZ6TDsPmrQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dFliIdRgEeKHbZ6TDsPmrQ" x="36" y="107" width="133"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_BrquMNRhEeKHbZ6TDsPmrQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BrquMtRhEeKHbZ6TDsPmrQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BrquM9RhEeKHbZ6TDsPmrQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BrquNNRhEeKHbZ6TDsPmrQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BrquNdRhEeKHbZ6TDsPmrQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_BrquNtRhEeKHbZ6TDsPmrQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_BrquN9RhEeKHbZ6TDsPmrQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_BrquONRhEeKHbZ6TDsPmrQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BrquOdRhEeKHbZ6TDsPmrQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BrquOtRhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BrquO9RhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BrquPNRhEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BrquPdRhEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BrquPtRhEeKHbZ6TDsPmrQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BrquP9RhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BrquQNRhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BrquQdRhEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BrquQtRhEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_BrquQ9RhEeKHbZ6TDsPmrQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_BrquRNRhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_BrquRdRhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_BrquRtRhEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BrquR9RhEeKHbZ6TDsPmrQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_BrSTsNRhEeKHbZ6TDsPmrQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_BrquMdRhEeKHbZ6TDsPmrQ" x="66" y="288"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_F0mScNRhEeKHbZ6TDsPmrQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_F0mSctRhEeKHbZ6TDsPmrQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_F0mSc9RhEeKHbZ6TDsPmrQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_F0mSdNRhEeKHbZ6TDsPmrQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_F0mSddRhEeKHbZ6TDsPmrQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_F0mSdtRhEeKHbZ6TDsPmrQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_F0mSd9RhEeKHbZ6TDsPmrQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_F0mSeNRhEeKHbZ6TDsPmrQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_F0mSedRhEeKHbZ6TDsPmrQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_F0mSetRhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_F0mSe9RhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_F0mSfNRhEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_F0mSfdRhEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_F0mSftRhEeKHbZ6TDsPmrQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_F0mSf9RhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_F0mSgNRhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_F0mSgdRhEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_F0mSgtRhEeKHbZ6TDsPmrQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_F0mSg9RhEeKHbZ6TDsPmrQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_F0mShNRhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_F0mShdRhEeKHbZ6TDsPmrQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_F0mShtRhEeKHbZ6TDsPmrQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_F0mSh9RhEeKHbZ6TDsPmrQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_F0T-kNRhEeKHbZ6TDsPmrQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_F0mScdRhEeKHbZ6TDsPmrQ" x="570" y="288"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_8t6EoNRpEeKHbZ6TDsPmrQ" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_8t6EotRpEeKHbZ6TDsPmrQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_8t6Eo9RpEeKHbZ6TDsPmrQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_8t6EpNRpEeKHbZ6TDsPmrQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_8t6EpdRpEeKHbZ6TDsPmrQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_8t6EptRpEeKHbZ6TDsPmrQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_8t6Ep9RpEeKHbZ6TDsPmrQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_8t6EqNRpEeKHbZ6TDsPmrQ" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_8tJPoNRpEeKHbZ6TDsPmrQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8t6EodRpEeKHbZ6TDsPmrQ" x="582" y="12" width="201"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_4z5MgNRxEeKHbZ6TDsPmrQ" type="2012" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_4z_TINRxEeKHbZ6TDsPmrQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_4z_TIdRxEeKHbZ6TDsPmrQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_4z_TItRxEeKHbZ6TDsPmrQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_4z_TI9RxEeKHbZ6TDsPmrQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_4z_TJNRxEeKHbZ6TDsPmrQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_4z_TJdRxEeKHbZ6TDsPmrQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_4z_TJtRxEeKHbZ6TDsPmrQ" type="5038"/>
+      <element xmi:type="uml:Comment" href="architecture-v3.uml#_4zs_QNRxEeKHbZ6TDsPmrQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_4z5MgdRxEeKHbZ6TDsPmrQ" x="42" y="6" width="175" height="79"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_TiMgUdRgEeKHbZ6TDsPmrQ"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_MIZBMNRgEeKHbZ6TDsPmrQ"/>
+    <edges xmi:type="notation:Connector" xmi:id="_bpqWsNRgEeKHbZ6TDsPmrQ" type="4001" source="_WW-VENRgEeKHbZ6TDsPmrQ" target="_XqfycNRgEeKHbZ6TDsPmrQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_bpqWs9RgEeKHbZ6TDsPmrQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bpwdUNRgEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_bpwdUdRgEeKHbZ6TDsPmrQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bpwdUtRgEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_bpwdU9RgEeKHbZ6TDsPmrQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bpwdVNRgEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_bpwdVdRgEeKHbZ6TDsPmrQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bpwdVtRgEeKHbZ6TDsPmrQ" x="-21" y="22"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_bpwdV9RgEeKHbZ6TDsPmrQ" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bpwdWNRgEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_bpwdWdRgEeKHbZ6TDsPmrQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bpwdWtRgEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_bpqWsdRgEeKHbZ6TDsPmrQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_bpFu8NRgEeKHbZ6TDsPmrQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_bpqWstRgEeKHbZ6TDsPmrQ" points="[3, -3, -152, 0]$[143, -6, -12, -3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_bp8qkNRgEeKHbZ6TDsPmrQ" id="(0.97,0.39)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_bp8qkdRgEeKHbZ6TDsPmrQ" id="(0.12,0.42)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_gYHC0NRgEeKHbZ6TDsPmrQ" type="4001" source="_dFliINRgEeKHbZ6TDsPmrQ" target="_WW-VENRgEeKHbZ6TDsPmrQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_gYNJcNRgEeKHbZ6TDsPmrQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gYNJcdRgEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gYNJctRgEeKHbZ6TDsPmrQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gYNJc9RgEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gYNJdNRgEeKHbZ6TDsPmrQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gYNJddRgEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gYNJdtRgEeKHbZ6TDsPmrQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gYNJd9RgEeKHbZ6TDsPmrQ" x="-28" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gYNJeNRgEeKHbZ6TDsPmrQ" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gYNJedRgEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gYNJetRgEeKHbZ6TDsPmrQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gYNJe9RgEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_gYHC0dRgEeKHbZ6TDsPmrQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_gX0u8NRgEeKHbZ6TDsPmrQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_gYHC0tRgEeKHbZ6TDsPmrQ" points="[8, -3, -174, 0]$[181, -4, -1, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_gYTQENRgEeKHbZ6TDsPmrQ" id="(0.9398496240601504,0.41)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_gYTQEdRgEeKHbZ6TDsPmrQ" id="(0.01,0.43)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_EfFRANRhEeKHbZ6TDsPmrQ" type="4001" source="_BrquMNRhEeKHbZ6TDsPmrQ" target="_Y8lscNRgEeKHbZ6TDsPmrQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_EfFRA9RhEeKHbZ6TDsPmrQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_EfFRBNRhEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_EfFRBdRhEeKHbZ6TDsPmrQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_EfFRBtRhEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_EfFRB9RhEeKHbZ6TDsPmrQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_EfFRCNRhEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_EfFRCdRhEeKHbZ6TDsPmrQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_EfFRCtRhEeKHbZ6TDsPmrQ" x="-37" y="28"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_EfFRC9RhEeKHbZ6TDsPmrQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_EfFRDNRhEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_EfFRDdRhEeKHbZ6TDsPmrQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_EfFRDtRhEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_EfFRAdRhEeKHbZ6TDsPmrQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_Eemv4NRhEeKHbZ6TDsPmrQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_EfFRAtRhEeKHbZ6TDsPmrQ" points="[7, 3, -187, 0]$[189, 3, -5, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_EfReQNRhEeKHbZ6TDsPmrQ" id="(0.93,0.51)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_EfReQdRhEeKHbZ6TDsPmrQ" id="(0.05,0.55)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_HrC2sNRhEeKHbZ6TDsPmrQ" type="4001" source="_Y8lscNRgEeKHbZ6TDsPmrQ" target="_F0mScNRhEeKHbZ6TDsPmrQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_HrC2s9RhEeKHbZ6TDsPmrQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_HrC2tNRhEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_HrC2tdRhEeKHbZ6TDsPmrQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_HrC2ttRhEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_HrC2t9RhEeKHbZ6TDsPmrQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_HrC2uNRhEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_HrC2udRhEeKHbZ6TDsPmrQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_HrC2utRhEeKHbZ6TDsPmrQ" x="-18" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_HrC2u9RhEeKHbZ6TDsPmrQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_HrC2vNRhEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_HrC2vdRhEeKHbZ6TDsPmrQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_HrC2vtRhEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_HrC2sdRhEeKHbZ6TDsPmrQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_HqkVkNRhEeKHbZ6TDsPmrQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_HrC2stRhEeKHbZ6TDsPmrQ" points="[9, 3, -130, 0]$[131, 4, -8, 1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_HrPD8NRhEeKHbZ6TDsPmrQ" id="(0.91,0.54)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_HrPD8dRhEeKHbZ6TDsPmrQ" id="(0.08,0.56)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_Ivq8cNRhEeKHbZ6TDsPmrQ" type="4001" source="_Y8lscNRgEeKHbZ6TDsPmrQ" target="_WW-VENRgEeKHbZ6TDsPmrQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ivq8c9RhEeKHbZ6TDsPmrQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ivq8dNRhEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ivq8ddRhEeKHbZ6TDsPmrQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ivq8dtRhEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ivq8d9RhEeKHbZ6TDsPmrQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ivq8eNRhEeKHbZ6TDsPmrQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ivq8edRhEeKHbZ6TDsPmrQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ivq8etRhEeKHbZ6TDsPmrQ" x="-8" y="52"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ivq8e9RhEeKHbZ6TDsPmrQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ivq8fNRhEeKHbZ6TDsPmrQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Ivq8fdRhEeKHbZ6TDsPmrQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Ivq8ftRhEeKHbZ6TDsPmrQ" x="-8" y="-27"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Ivq8cdRhEeKHbZ6TDsPmrQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_IvSh8NRhEeKHbZ6TDsPmrQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Ivq8ctRhEeKHbZ6TDsPmrQ" points="[4, -4, 0, 88]$[1, -85, -3, 7]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Iv3JsNRhEeKHbZ6TDsPmrQ" id="(0.42,0.04)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Iv3JsdRhEeKHbZ6TDsPmrQ" id="(0.39097744360902253,0.9326923076923077)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_C6rDcNeMEeKpd73UUMObaQ" type="PapyrusUMLClassDiagram" name="property" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_IQQoENeMEeKpd73UUMObaQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IQQoEteMEeKpd73UUMObaQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IQQoE9eMEeKpd73UUMObaQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IQQoFNeMEeKpd73UUMObaQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IQQoFdeMEeKpd73UUMObaQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IQQoFteMEeKpd73UUMObaQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IQQoF9eMEeKpd73UUMObaQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_IQQoGNeMEeKpd73UUMObaQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_IQQoGdeMEeKpd73UUMObaQ" type="7017">
+        <children xmi:type="notation:Shape" xmi:id="_CC7GoNeNEeKpd73UUMObaQ" type="3012" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_xNNKINIPEeKovM8ingMMQQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_CC7GodeNEeKpd73UUMObaQ" x="42" y="3"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_IQQoGteMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_IQQoG9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_IQQoHNeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IQQoHdeMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_IQQoHteMEeKpd73UUMObaQ" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_ND_AUNeNEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_NDsscNeNEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_ND_AUdeNEeKpd73UUMObaQ"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_IQQoH9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_IQQoINeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_IQQoIdeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IQQoIteMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_IQQoI9eMEeKpd73UUMObaQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_IQQoJNeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_IQQoJdeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_IQQoJteMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IQQoJ9eMEeKpd73UUMObaQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_UzekYM-yEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IQQoEdeMEeKpd73UUMObaQ" x="324" y="126" height="223"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_JeFGENeMEeKpd73UUMObaQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_JeFGEteMEeKpd73UUMObaQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_JeFGE9eMEeKpd73UUMObaQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_JeFGFNeMEeKpd73UUMObaQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_JeFGFdeMEeKpd73UUMObaQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_JeFGFteMEeKpd73UUMObaQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_JeFGF9eMEeKpd73UUMObaQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_JeFGGNeMEeKpd73UUMObaQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_JeFGGdeMEeKpd73UUMObaQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_JeFGGteMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_JeFGG9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_JeFGHNeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_JeFGHdeMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_JeFGHteMEeKpd73UUMObaQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_JeFGH9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_JeFGINeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_JeFGIdeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_JeFGIteMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_JeFGI9eMEeKpd73UUMObaQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_JeFGJNeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_JeFGJdeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_JeFGJteMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_JeFGJ9eMEeKpd73UUMObaQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_SZ1McM-yEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_JeFGEdeMEeKpd73UUMObaQ" x="654" y="12"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_QKDO0NeMEeKpd73UUMObaQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QKJVcNeMEeKpd73UUMObaQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_QKJVcdeMEeKpd73UUMObaQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QKJVcteMEeKpd73UUMObaQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_QKJVc9eMEeKpd73UUMObaQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_QKJVdNeMEeKpd73UUMObaQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_QKJVddeMEeKpd73UUMObaQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_QKJVdteMEeKpd73UUMObaQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_QKJVd9eMEeKpd73UUMObaQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_QKJVeNeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_QKJVedeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_QKJVeteMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QKJVe9eMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_QKJVfNeMEeKpd73UUMObaQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_QKJVfdeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_QKJVfteMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_QKJVf9eMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QKJVgNeMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_QKJVgdeMEeKpd73UUMObaQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_QKJVgteMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_QKJVg9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_QKJVhNeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QKJVhdeMEeKpd73UUMObaQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_l4yNkM-0EeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_QKDO0deMEeKpd73UUMObaQ" x="660" y="180" height="169"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_WMui8NeMEeKpd73UUMObaQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_WMui8teMEeKpd73UUMObaQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_WMui89eMEeKpd73UUMObaQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_WMui9NeMEeKpd73UUMObaQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_WMui9deMEeKpd73UUMObaQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_WMui9teMEeKpd73UUMObaQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_WMui99eMEeKpd73UUMObaQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WMui-NeMEeKpd73UUMObaQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WMui-deMEeKpd73UUMObaQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WMui-teMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WMui-9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WMui_NeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WMui_deMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WMui_teMEeKpd73UUMObaQ" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WMui_9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WMujANeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WMujAdeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WMujAteMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WMujA9eMEeKpd73UUMObaQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WMujBNeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WMujBdeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WMujBteMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WMujB9eMEeKpd73UUMObaQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_WMWIcNeMEeKpd73UUMObaQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WMui8deMEeKpd73UUMObaQ" x="42" y="36" width="117" height="151"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_jrOIYNeMEeKpd73UUMObaQ" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jrOIYteMEeKpd73UUMObaQ" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jrOIY9eMEeKpd73UUMObaQ" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jrOIZNeMEeKpd73UUMObaQ" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jrOIZdeMEeKpd73UUMObaQ" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_jrOIZteMEeKpd73UUMObaQ" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_jrOIZ9eMEeKpd73UUMObaQ" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_jrOIaNeMEeKpd73UUMObaQ" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jrOIadeMEeKpd73UUMObaQ" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jrOIateMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jrOIa9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jrOIbNeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jrOIbdeMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jrOIbteMEeKpd73UUMObaQ" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_oixGINeMEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_urYKgNeJEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_oixGIdeMEeKpd73UUMObaQ" x="26" y="10"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_qVMGANeMEeKpd73UUMObaQ" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_AYzD8NeJEeKpd73UUMObaQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_qVMGAdeMEeKpd73UUMObaQ" x="19" y="21"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jrOIb9eMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jrOIcNeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jrOIcdeMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jrOIcteMEeKpd73UUMObaQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_jrOIc9eMEeKpd73UUMObaQ" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_jrOIdNeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_jrOIddeMEeKpd73UUMObaQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_jrOIdteMEeKpd73UUMObaQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jrOId9eMEeKpd73UUMObaQ"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_uIcTcM-wEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_jrOIYdeMEeKpd73UUMObaQ" x="36" y="330"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_C6rDcdeMEeKpd73UUMObaQ"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_KxbdELZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_PGankNeMEeKpd73UUMObaQ" type="4001" source="_JeFGENeMEeKpd73UUMObaQ" target="_IQQoENeMEeKpd73UUMObaQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_PGank9eMEeKpd73UUMObaQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PGanlNeMEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PGanldeMEeKpd73UUMObaQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PGanlteMEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PGanl9eMEeKpd73UUMObaQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PGanmNeMEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PGanmdeMEeKpd73UUMObaQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PGanmteMEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PGanm9eMEeKpd73UUMObaQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PGannNeMEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PGanndeMEeKpd73UUMObaQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PGannteMEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_PGankdeMEeKpd73UUMObaQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_mjiFoM-yEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_PGankteMEeKpd73UUMObaQ" points="[-57, 20, 144, -53]$[-138, 50, 63, -23]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_S9ME0NeMEeKpd73UUMObaQ" type="4001" source="_QKDO0NeMEeKpd73UUMObaQ" target="_IQQoENeMEeKpd73UUMObaQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_S9ME09eMEeKpd73UUMObaQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S9ME1NeMEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S9ME1deMEeKpd73UUMObaQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S9ME1teMEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S9ME19eMEeKpd73UUMObaQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S9ME2NeMEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S9ME2deMEeKpd73UUMObaQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S9ME2teMEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S9ME29eMEeKpd73UUMObaQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S9ME3NeMEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S9ME3deMEeKpd73UUMObaQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S9ME3teMEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_S9ME0deMEeKpd73UUMObaQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_OFj2sM-5EeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_S9ME0teMEeKpd73UUMObaQ" points="[-50, -9, 235, 38]$[-184, -31, 101, 16]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_BPfCENeOEeKpd73UUMObaQ" id="(0.02,0.3609467455621302)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_cYuVsNeNEeKpd73UUMObaQ" type="4001" source="_IQQoENeMEeKpd73UUMObaQ" target="_QKDO0NeMEeKpd73UUMObaQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_cYvj0NeNEeKpd73UUMObaQ" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cYvj0deNEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cYvj0teNEeKpd73UUMObaQ" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cYvj09eNEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cYwK4NeNEeKpd73UUMObaQ" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cYwK4deNEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cYwK4teNEeKpd73UUMObaQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cYwK49eNEeKpd73UUMObaQ" x="-38" y="30"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cYwx8NeNEeKpd73UUMObaQ" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cYwx8deNEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cYwx8teNEeKpd73UUMObaQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cYwx89eNEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_cYuVsdeNEeKpd73UUMObaQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_cYKVANeNEeKpd73UUMObaQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_cYuVsteNEeKpd73UUMObaQ" points="[10, 1, -140, -26]$[144, 30, -6, 3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_cY7xENeNEeKpd73UUMObaQ" id="(0.9504950495049505,0.8956521739130435)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_cY7xEdeNEeKpd73UUMObaQ" id="(0.05,0.8520710059171598)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_H_WMUNeOEeKpd73UUMObaQ" type="4001" source="_WMui8NeMEeKpd73UUMObaQ" target="_IQQoENeMEeKpd73UUMObaQ" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_H_WMU9eOEeKpd73UUMObaQ" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_H_WMVNeOEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_H_WMVdeOEeKpd73UUMObaQ" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_H_WMVteOEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_H_WMV9eOEeKpd73UUMObaQ" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_H_WMWNeOEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_H_WMWdeOEeKpd73UUMObaQ" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_H_WMWteOEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_H_WMW9eOEeKpd73UUMObaQ" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_H_WMXNeOEeKpd73UUMObaQ" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_H_WMXdeOEeKpd73UUMObaQ" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_H_WMXteOEeKpd73UUMObaQ" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_H_WMUdeOEeKpd73UUMObaQ" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_H-9x0NeOEeKpd73UUMObaQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_H_WMUteOEeKpd73UUMObaQ" points="[5, 0, -168, -10]$[170, 7, -3, -3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_H_iZkNeOEeKpd73UUMObaQ" id="(0.9572649572649573,0.6688741721854304)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_H_iZkdeOEeKpd73UUMObaQ" id="(0.01485148514851485,0.09417040358744394)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_rVlkIEydEeObF6ELIGKT-g" type="PapyrusUMLClassDiagram" name="notifiers" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_-maNMEygEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-ma0QEygEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-mbbUEygEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-mbbUUygEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-mbbUkygEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-mcCYEygEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-mcCYUygEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_-mcCYkygEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_-mcCY0ygEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_-mcCZEygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_-mcCZUygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_-mcCZkygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-mcCZ0ygEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_-mcpcEygEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_-mcpcUygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_-mcpckygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_-mcpc0ygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-mcpdEygEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_-mcpdUygEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_-mcpdkygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_-mcpd0ygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_-mcpeEygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-mcpeUygEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_-mWi0EygEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-maNMUygEeObF6ELIGKT-g" x="126" y="80" width="427"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_GmVRIEyhEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GmWfQEyhEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GmWfQUyhEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GmWfQkyhEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GmWfQ0yhEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GmXGUEyhEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GmXGUUyhEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_GmXGUkyhEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_GmXGU0yhEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_GmXGVEyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_GmXGVUyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_GmXGVkyhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GmXGV0yhEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_GmXtYEyhEeObF6ELIGKT-g" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_L2LaIEyhEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_L2KMAEyhEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_L2LaIUyhEeObF6ELIGKT-g"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_M_ytkEyhEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_M_w4YEyhEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_M_ytkUyhEeObF6ELIGKT-g"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_GmXtYUyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_GmXtYkyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_GmXtY0yhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GmXtZEyhEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_GmYUcEyhEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_GmYUcUyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_GmYUckyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_GmYUc0yhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GmYUdEyhEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_GmQYoEyhEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GmVRIUyhEeObF6ELIGKT-g" x="828" y="72" width="257"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_VVjeoEyhEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_VVkFsEyhEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_VVkFsUyhEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_VVkswEyhEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_VVkswUyhEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_VVkswkyhEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_VVksw0yhEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VVksxEyhEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_VVlT0EyhEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_VVlT0UyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_VVlT0kyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_VVlT00yhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_VVlT1EyhEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_VVlT1UyhEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_VVlT1kyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_VVlT10yhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_VVlT2EyhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_VVlT2UyhEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_VVl64EyhEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_VVl64UyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_VVl64kyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_VVl640yhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_VVl65EyhEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_VVf0QEyhEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_VVjeoUyhEeObF6ELIGKT-g" x="126" y="210" width="427"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_lo040EyhEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_lo2G8EyhEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_lo2G8UyhEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_lo2G8kyhEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_lo2G80yhEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_lo2uAEyhEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_lo2uAUyhEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_lo2uAkyhEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_lo2uA0yhEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_lo2uBEyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_lo2uBUyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_lo2uBkyhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_lo2uB0yhEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_lo3VEEyhEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_lo3VEUyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_lo3VEkyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_lo3VE0yhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_lo3VFEyhEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_lo38IEyhEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_lo38IUyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_lo38IkyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_lo38I0yhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_lo38JEyhEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_loxOcEyhEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_lo040UyhEeObF6ELIGKT-g" x="136" y="390"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_qDvk8EyhEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_qDwzEEyhEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_qDwzEUyhEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_qDxaIEyhEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_qDxaIUyhEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_qDxaIkyhEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_qDxaI0yhEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qDyBMEyhEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_qDyBMUyhEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_qDyBMkyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_qDyBM0yhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_qDyBNEyhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qDyBNUyhEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_qDyoQEyhEeObF6ELIGKT-g" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_s_I_EEyhEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_s_IYAEyhEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_s_I_EUyhEeObF6ELIGKT-g"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_qDyoQUyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_qDyoQkyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_qDyoQ0yhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qDyoREyhEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_qDyoRUyhEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_qDyoRkyhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_qDyoR0yhEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_qDyoSEyhEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qDyoSUyhEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_qDr6kEyhEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qDvk8UyhEeObF6ELIGKT-g" x="834" y="384"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_dK2xgEyiEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_dK4msEyiEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_dK4msUyiEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_dK4mskyiEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_dK4ms0yiEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_dK5NwEyiEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_dK5NwUyiEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_dK5NwkyiEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dK5Nw0yiEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dK5NxEyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dK5NxUyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dK5NxkyiEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dK5Nx0yiEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dK500EyiEeObF6ELIGKT-g" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_fdtk8EyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_h69BYNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fdtk8UyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fdwBMEyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_iKn1ENNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fdwBMUyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fdx2YEyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_iGe78NNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fdx2YUyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fd0SoEyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_1WChENNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fd0SoUyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fd2H0EyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_iUNO4NNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fd2H0UyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fd5LIEyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_SmexwNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fd5LIUyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fd7AUEyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_h5JDgNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fd7AUUyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fd8OcEyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_htRxwNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fd8OcUyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fd9ckEyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_1iV3sNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fd9ckUyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fd_RwEyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_94G1IN9lEeKCZbxNW-U3VQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fd_RwUyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_feAf4EyiEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_1mcUkNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_feAf4UyiEeObF6ELIGKT-g" x="45" y="4"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dK500UyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dK500kyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dK5000yiEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dK501EyiEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dK501UyiEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dK501kyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dK5010yiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dK502EyiEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dK502UyiEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_OS41oNNqEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dK2xgUyiEeObF6ELIGKT-g" x="834" y="540"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_-owEoEyiEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-oxSwEyiEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-oxSwUyiEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-oxSwkyiEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-ox50EyiEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_-ox50UyiEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_-ox50kyiEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_-ox500yiEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_-oyg4EyiEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_-oyg4UyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_-oyg4kyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_-oyg40yiEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-oyg5EyiEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_-oyg5UyiEeObF6ELIGKT-g" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_T8GGcEyjEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_JZ7ioNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_T8GGcUyjEeObF6ELIGKT-g" x="23" y="7"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_T8KX4EyjEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_Ft6TwN9mEeKCZbxNW-U3VQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_T8KX4UyjEeObF6ELIGKT-g" x="23" y="7"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_-oyg5kyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_-oyg50yiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_-oyg6EyiEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-oyg6UyiEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_-ozH8EyiEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_-ozH8UyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_-ozH8kyiEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_-ozH80yiEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-ozH9EyiEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_HJLoANNqEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-owEoUyiEeObF6ELIGKT-g" x="834" y="882"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_LY9nwEyjEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LY-14EyjEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LY_c8EyjEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LY_c8UyjEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LY_c8kyjEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LY_c80yjEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LZAEAEyjEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_LZAEAUyjEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LZAEAkyjEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LZAEA0yjEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LZAEBEyjEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LZAEBUyjEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LZAEBkyjEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LZArEEyjEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LZArEUyjEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LZArEkyjEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LZArE0yjEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LZArFEyjEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LZArFUyjEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LZArFkyjEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LZArF0yjEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LZArGEyjEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LZArGUyjEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_JwRLoEyjEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LY9nwUyjEeObF6ELIGKT-g" x="168" y="900"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_a8t0EEykEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_a8vCMEykEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_a8vCMUykEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_a8vCMkykEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_a8vCM0ykEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_a8vCNEykEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_a8vpQEykEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_a8vpQUykEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_a8vpQkykEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_a8vpQ0ykEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_a8vpREykEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_a8vpRUykEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_a8vpRkykEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_a8wQUEykEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_a8wQUUykEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_a8wQUkykEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_a8wQU0ykEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_a8wQVEykEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_a8wQVUykEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_a8wQVkykEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_a8wQV0ykEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_a8wQWEykEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_a8wQWUykEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_a8pioEykEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_a8t0EUykEeObF6ELIGKT-g" x="156" y="624"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_l9pYoEypEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l9p_sEypEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l9p_sUypEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l9p_skypEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l9p_s0ypEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_l9p_tEypEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_l9p_tUypEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_l9p_tkypEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l9p_t0ypEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l9p_uEypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l9p_uUypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l9p_ukypEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l9p_u0ypEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l9p_vEypEeObF6ELIGKT-g" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_Wxds4EyqEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_WxdF0EyqEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Wxds4UyqEeObF6ELIGKT-g"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_YPAB4EyqEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_YO_a0EyqEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_YPAB4UyqEeObF6ELIGKT-g"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Z0-hMEyqEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GOzWYEyrEeObF6ELIGKT-g" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Hwd9cEyrEeObF6ELIGKT-g" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_Z096IEyqEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Z0-hMUyqEeObF6ELIGKT-g"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_bz8IQEyqEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_bz66IEyqEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_bz8IQUyqEeObF6ELIGKT-g"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l9p_vUypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l9p_vkypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l9p_v0ypEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l9p_wEypEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_l9p_wUypEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_l9p_wkypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_l9p_w0ypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_l9p_xEypEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l9p_xUypEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_l9oKgEypEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_l9pYoUypEeObF6ELIGKT-g" x="144" y="1062" width="265"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_qwHCEEypEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_qwIQMEypEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_qwIQMUypEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_qwIQMkypEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_qwIQM0ypEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_qwI3QEypEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_qwI3QUypEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_qwI3QkypEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_qwI3Q0ypEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_qwI3REypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_qwI3RUypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_qwI3RkypEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qwI3R0ypEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_qwJeUEypEeObF6ELIGKT-g" type="7007">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_qwJeUUypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_qwJeUkypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_qwJeU0ypEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qwJeVEypEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_qwJeVUypEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_qwJeVkypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_qwJeV0ypEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_qwJeWEypEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qwJeWUypEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_qwDXsEypEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qwHCEUypEeObF6ELIGKT-g" x="828" y="1074"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_H5OekEywEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_H5PFoEywEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_H5PFoUywEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_H5PFokywEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_H5PFo0ywEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_H5PFpEywEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_H5PFpUywEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_H5PFpkywEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_H5PFp0ywEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_H5PFqEywEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_H5PFqUywEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_H5PFqkywEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H5PFq0ywEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_H5PFrEywEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_H5PFrUywEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_H5PFrkywEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_H5PFr0ywEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H5PFsEywEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_H5PssEywEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_H5PssUywEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_H5PsskywEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_H5Pss0ywEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H5PstEywEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rezFUEyvEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H5OekUywEeObF6ELIGKT-g" x="114" y="1278"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_rVlkIUydEeObF6ELIGKT-g"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_IygSQLZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_Z_uuwEyhEeObF6ELIGKT-g" type="4007" source="_-maNMEygEeObF6ELIGKT-g" target="_GmVRIEyhEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Z_v84EyhEeObF6ELIGKT-g" visible="false" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Z_wj8EyhEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Z_wj8UyhEeObF6ELIGKT-g" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Z_wj8kyhEeObF6ELIGKT-g" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Z_uuwUyhEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_Z_oBEEyhEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Z_uuwkyhEeObF6ELIGKT-g" points="[7, -3, -275, 0]$[282, -3, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_aAC30EyhEeObF6ELIGKT-g" id="(0.9836065573770492,0.41)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_aAC30UyhEeObF6ELIGKT-g" id="(0.0,0.3194444444444444)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_bc86sEyhEeObF6ELIGKT-g" type="4007" source="_VVjeoEyhEeObF6ELIGKT-g" target="_GmVRIEyhEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_bc-v4EyhEeObF6ELIGKT-g" visible="false" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bc-v4UyhEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_bc-v4kyhEeObF6ELIGKT-g" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bc_W8EyhEeObF6ELIGKT-g" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_bc86sUyhEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_bc3bIEyhEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_bc86skyhEeObF6ELIGKT-g" points="[7, -3, -276, 98]$[282, -101, -1, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_bdLkMEyhEeObF6ELIGKT-g" id="(0.9836065573770492,0.42)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_bdMLQEyhEeObF6ELIGKT-g" id="(0.0038910505836575876,0.8402777777777778)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_uanekEyhEeObF6ELIGKT-g" type="4007" source="_lo040EyhEeObF6ELIGKT-g" target="_qDvk8EyhEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_uaossEyhEeObF6ELIGKT-g" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uaossUyhEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uapTwEyhEeObF6ELIGKT-g" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uapTwUyhEeObF6ELIGKT-g" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_uanekUyhEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_uaimEEyhEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_uanekkyhEeObF6ELIGKT-g" points="[4, -6, -339, 0]$[340, -7, -3, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ua2vIEyhEeObF6ELIGKT-g" id="(0.988950276243094,0.47)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ua3WMEyhEeObF6ELIGKT-g" id="(0.011029411764705883,0.3790322580645161)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_Soo6gEyjEeObF6ELIGKT-g" type="4007" source="_LY9nwEyjEeObF6ELIGKT-g" target="_-owEoEyiEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_SoqIoEyjEeObF6ELIGKT-g" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_SoqvsEyjEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_SoqvsUyjEeObF6ELIGKT-g" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_SorWwEyjEeObF6ELIGKT-g" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Soo6gUyjEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_SokpEEyjEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Soo6gkyjEeObF6ELIGKT-g" points="[8, 2, -488, 0]$[496, 2, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Sow2UEyjEeObF6ELIGKT-g" id="(0.9550561797752809,0.37)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Sow2UUyjEeObF6ELIGKT-g" id="(0.0,0.39823008849557523)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_cXw1wEykEeObF6ELIGKT-g" type="4007" source="_a8t0EEykEeObF6ELIGKT-g" target="_dK2xgEyiEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_cXyD4EykEeObF6ELIGKT-g" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cXyq8EykEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cXyq8UykEeObF6ELIGKT-g" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cXyq8kykEeObF6ELIGKT-g" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_cXw1wUykEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_cXr9QEykEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_cXw1wkykEeObF6ELIGKT-g" points="[7, 7, -506, 0]$[513, 7, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_cX-RIEykEeObF6ELIGKT-g" id="(0.9593023255813954,0.35)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_cX-RIUykEeObF6ELIGKT-g" id="(0.0,0.3888888888888889)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_uEIXkEypEeObF6ELIGKT-g" type="4007" source="_l9pYoEypEeObF6ELIGKT-g" target="_qwHCEEypEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_uEJlsEypEeObF6ELIGKT-g" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uEJlsUypEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uEJlskypEeObF6ELIGKT-g" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_uEJls0ypEeObF6ELIGKT-g" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_uEIXkUypEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_uEDfEEypEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_uEIXkkypEeObF6ELIGKT-g" points="[4, 1, -403, 0]$[405, 0, -2, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_uENQEEypEeObF6ELIGKT-g" id="(0.9849056603773585,0.52)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_uENQEUypEeObF6ELIGKT-g" id="(0.011320754716981131,0.6371681415929203)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_NrFIcEywEeObF6ELIGKT-g" type="4007" source="_H5OekEywEeObF6ELIGKT-g" target="_qwHCEEypEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_NrFIc0ywEeObF6ELIGKT-g" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_NrFvgEywEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_NrFvgUywEeObF6ELIGKT-g" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_NrFvgkywEeObF6ELIGKT-g" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_NrFIcUywEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_NrCFIEywEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_NrFIckywEeObF6ELIGKT-g" points="[9, -3, -405, 127]$[409, -129, -5, 1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_NrIy0EywEeObF6ELIGKT-g" id="(0.9713375796178344,0.3)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_NrIy0UywEeObF6ELIGKT-g" id="(0.019230769230769232,0.9203539823008849)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_WYXosEywEeObF6ELIGKT-g" type="4001" source="_H5OekEywEeObF6ELIGKT-g" target="_l9pYoEypEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_WYYPwEywEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WYYPwUywEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WYYPwkywEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WYYPw0ywEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WYYPxEywEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WYYPxUywEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WYYPxkywEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WYYPx0ywEeObF6ELIGKT-g" x="-12" y="6"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WYYPyEywEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WYYPyUywEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WYYPykywEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WYYPy0ywEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_WYXosUywEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_WYWakEywEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_WYXoskywEeObF6ELIGKT-g" points="[1, -2, 0, 56]$[1, -54, 0, 4]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_WYs_4EywEeObF6ELIGKT-g" id="(0.5254777070063694,0.02)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_WYs_4UywEeObF6ELIGKT-g" id="(0.5132075471698113,0.975609756097561)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_gjq_EEywEeObF6ELIGKT-g" type="4001" source="_H5OekEywEeObF6ELIGKT-g" target="_LY9nwEyjEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_gjsNMEywEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gjs0QEywEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gjs0QUywEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gjs0QkywEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gjs0Q0ywEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gjtbUEywEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gjtbUUywEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gjtbUkywEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gjtbU0ywEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gjuCYEywEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_gjuCYUywEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_gjuCYkywEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_gjq_EUywEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_gjmtoEywEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_gjq_EkywEeObF6ELIGKT-g" points="[-3, 0, -59, 308]$[-45, 0, -101, 308]$[-45, -308, -101, 0]$[51, -308, -5, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_gj62sEywEeObF6ELIGKT-g" id="(0.009554140127388535,0.07)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_gj62sUywEeObF6ELIGKT-g" id="(0.028089887640449437,0.77)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_uPIkIEydEeObF6ELIGKT-g" type="PapyrusUMLClassDiagram" name="RegExpSynchronizer" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_z8-QsEydEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_z9As8EydEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_z9As8UydEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_z9BUAEydEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_z9BUAUydEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_z9BUAkydEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_z9BUA0ydEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_z9BUBEydEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_z9BUBUydEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_z9BUBkydEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_z9BUB0ydEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_z9BUCEydEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z9BUCUydEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_z9B7EEydEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_z9B7EUydEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_z9B7EkydEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_z9B7E0ydEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z9B7FEydEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_z9B7FUydEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_z9B7FkydEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_z9B7F0ydEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_z9B7GEydEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z9B7GUydEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_z8UwcEydEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8-QsUydEeObF6ELIGKT-g" x="474" y="54" width="229" height="835"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_AeBEgEygEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_AeCSoEygEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_AeCSoUygEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_AeC5sEygEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_AeC5sUygEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_AeC5skygEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_AeC5s0ygEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_AeDgwEygEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_AeDgwUygEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_AeDgwkygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_AeDgw0ygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_AeDgxEygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AeDgxUygEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_AeDgxkygEeObF6ELIGKT-g" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_PEsaAEygEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_JZ7ioNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_PEsaAUygEeObF6ELIGKT-g" x="31" y="5"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_PEzuwEygEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_Ft6TwN9mEeKCZbxNW-U3VQ"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_PEzuwUygEeObF6ELIGKT-g" x="31" y="5"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_AeEH0EygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_AeEH0UygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_AeEH0kygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AeEH00ygEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_AeEH1EygEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_AeEH1UygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_AeEH1kygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_AeEH10ygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AeEH2EygEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_HJLoANNqEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AeBEgUygEeObF6ELIGKT-g" x="918" y="996"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_CpYI0EygEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_CpYI0kygEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_CpYI00ygEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_CpYv4EygEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_CpYv4UygEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_CpYv4kygEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_CpYv40ygEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_CpYv5EygEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_CpYv5UygEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_CpYv5kygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_CpYv50ygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_CpYv6EygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CpYv6UygEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_CpYv6kygEeObF6ELIGKT-g" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_UbtiAEygEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_h69BYNNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_UbtiAUygEeObF6ELIGKT-g" x="56" y="15"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_UbzooEygEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_iGe78NNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_UbzooUygEeObF6ELIGKT-g" x="56" y="15"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Ub6WUEygEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_iKn1ENNqEeKwWoA8j13SIg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Ub6WUUygEeObF6ELIGKT-g" x="56" y="15"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_CpYv60ygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_CpYv7EygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_CpYv7UygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CpYv7kygEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_CpYv70ygEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_CpYv8EygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_CpYv8UygEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_CpYv8kygEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CpYv80ygEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_OS41oNNqEeKwWoA8j13SIg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CpYI0UygEeObF6ELIGKT-g" x="912" y="234"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_LOaSsEylEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LObg0EylEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LObg0UylEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LObg0kylEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LObg00ylEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_LOcH4EylEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_LOcH4UylEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_LOcH4kylEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LOcH40ylEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LOcH5EylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LOcH5UylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LOcH5kylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LOcH50ylEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LOcu8EylEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LOcu8UylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LOcu8kylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LOcu80ylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LOcu9EylEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_LOcu9UylEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_LOcu9kylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_LOcu90ylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_LOcu-EylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LOcu-UylEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_t0NNoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LOaSsUylEeObF6ELIGKT-g" x="252" y="342"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_NvUJMEylEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NvVXUEylEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NvVXUUylEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NvVXUkylEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NvVXU0ylEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NvV-YEylEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NvV-YUylEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_NvV-YkylEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_NvV-Y0ylEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_NvV-ZEylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_NvV-ZUylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_NvV-ZkylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NvV-Z0ylEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_NvWlcEylEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_NvWlcUylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_NvWlckylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_NvWlc0ylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NvWldEylEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_NvWldUylEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_NvWldkylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_NvWld0ylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_NvWleEylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NvWleUylEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rqknoM9UEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NvUJMUylEeObF6ELIGKT-g" x="42" y="342"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_iIwHgEylEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iIwukEylEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iIxVoEylEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iIxVoUylEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iIxVokylEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_iIxVo0ylEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_iIx8sEylEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_iIx8sUylEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iIx8skylEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iIx8s0ylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iIx8tEylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iIx8tUylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iIx8tkylEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iIyjwEylEeObF6ELIGKT-g" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_32niIEylEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_32mUAEylEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_32niIUylEeObF6ELIGKT-g"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_52JJ4EylEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_52Ii0EylEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_52JJ4UylEeObF6ELIGKT-g"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_71Zr4EylEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_71ZE0EylEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_71Zr4UylEeObF6ELIGKT-g"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iIyjwUylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iIyjwkylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iIyjw0ylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iIyjxEylEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_iIyjxUylEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_iIyjxkylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_iIyjx0ylEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_iIyjyEylEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iIyjyUylEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_iIr2EEylEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_iIwHgUylEeObF6ELIGKT-g" x="1308" y="630" width="349"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_NNIMsEymEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NNIMskymEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NNIMs0ymEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NNIMtEymEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NNIMtUymEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_NNIMtkymEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_NNIzwEymEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_NNIzwUymEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_NNIzwkymEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_NNIzw0ymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_NNIzxEymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_NNIzxUymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NNIzxkymEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_NNIzx0ymEeObF6ELIGKT-g" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_KiEQcEytEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_KiB0MEytEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_KiEQcUytEeObF6ELIGKT-g"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_MEEOsEytEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_MECZgEytEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_MEEOsUytEeObF6ELIGKT-g"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_NNIzyEymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_NNIzyUymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_NNIzykymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NNIzy0ymEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_NNIzzEymEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_NNIzzUymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_NNIzzkymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_NNIzz0ymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NNIz0EymEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_NNG-kEymEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_NNIMsUymEeObF6ELIGKT-g" x="918" y="612" width="211"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_PH4CIEymEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PH5QQEymEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PH5QQUymEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PH5QQkymEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PH5QQ0ymEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PH53UEymEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PH53UUymEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PH53UkymEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_PH53U0ymEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_PH53VEymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_PH53VUymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_PH53VkymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PH53V0ymEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_PH6eYEymEeObF6ELIGKT-g" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_1alD4EytEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_xe-J8EytEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_1alD4UytEeObF6ELIGKT-g" x="94" y="10"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_1arKgEytEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_xe-J8UytEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_1arKgUytEeObF6ELIGKT-g" x="94" y="10"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_PH6eYUymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_PH6eYkymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_PH6eY0ymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PH6eZEymEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_PH6eZUymEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_PH6eZkymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_PH6eZ0ymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_PH6eaEymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PH6eaUymEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_PHzwsEymEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PH4CIUymEeObF6ELIGKT-g" x="918" y="786" width="307"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_hYeEoEymEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hYfSwEymEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hYfSwUymEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hYfSwkymEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hYf50EymEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hYf50UymEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hYf50kymEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_hYf500ymEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hYgg4EymEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hYgg4UymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hYgg4kymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hYgg40ymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hYgg5EymEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hYgg5UymEeObF6ELIGKT-g" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_psa30EymEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_psYbkEymEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_psa30UymEeObF6ELIGKT-g"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_vtjT0EymEeObF6ELIGKT-g" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_vtheoEymEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_vtjT0UymEeObF6ELIGKT-g"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hYgg5kymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hYgg50ymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hYgg6EymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hYgg6UymEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hYhH8EymEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hYhH8UymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hYhH8kymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hYhH80ymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hYhH9EymEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_hYZzMEymEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hYeEoUymEeObF6ELIGKT-g" x="912" y="426" width="331"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_7ths0EymEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_7ti68EymEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_7ti68UymEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_7tjiAEymEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_7tjiAUymEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_7tjiAkymEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_7tjiA0ymEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_7tjiBEymEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_7tkJEEymEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_7tkJEUymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_7tkJEkymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_7tkJE0ymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_7tkJFEymEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_7tkJFUymEeObF6ELIGKT-g" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_LTBowEysEeObF6ELIGKT-g" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_LTBBsEysEeObF6ELIGKT-g"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_LTBowUysEeObF6ELIGKT-g"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_7tkJFkymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_7tkJF0ymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_7tkJGEymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_7tkJGUymEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_7tkwIEymEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_7tkwIUymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_7tkwIkymEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_7tkwI0ymEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_7tkwJEymEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_u6-HIM-xEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_7ths0UymEeObF6ELIGKT-g" x="1380" y="468"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_i4LxoEyrEeObF6ELIGKT-g" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_i4M_wEyrEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_i4M_wUyrEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_i4M_wkyrEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_i4Nm0EyrEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_i4Nm0UyrEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_i4Nm0kyrEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_i4Nm00yrEeObF6ELIGKT-g" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_i4Nm1EyrEeObF6ELIGKT-g" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_i4Nm1UyrEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_i4Nm1kyrEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_i4Nm10yrEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_i4Nm2EyrEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_i4ON4EyrEeObF6ELIGKT-g" type="7007">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_i4ON4UyrEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_i4ON4kyrEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_i4ON40yrEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_i4ON5EyrEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_i4O08EyrEeObF6ELIGKT-g" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_i4O08UyrEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_i4O08kyrEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_i4O080yrEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_i4O09EyrEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_qwDXsEypEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_i4LxoUyrEeObF6ELIGKT-g" x="-6" y="624"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_H2io4EyuEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_H2jP8EyuEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_H2j3AEyuEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_H2j3AUyuEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_H2j3AkyuEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_H2j3A0yuEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_H2j3BEyuEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_H2keEEyuEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_H2keEUyuEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_H2keEkyuEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_H2keE0yuEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_H2keFEyuEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H2keFUyuEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_H2lFIEyuEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_H2lFIUyuEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_H2lFIkyuEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_H2lFI0yuEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H2lFJEyuEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_H2lFJUyuEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_H2lFJkyuEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_H2lFJ0yuEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_H2lFKEyuEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H2lFKUyuEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_JwRLoEyjEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H2io4UyuEeObF6ELIGKT-g" x="1134" y="995"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_rezsYEyvEeObF6ELIGKT-g" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_re0TcEyvEeObF6ELIGKT-g" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_re0TcUyvEeObF6ELIGKT-g" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_re0TckyvEeObF6ELIGKT-g" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_re0Tc0yvEeObF6ELIGKT-g" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_re0TdEyvEeObF6ELIGKT-g" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_re0TdUyvEeObF6ELIGKT-g" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_re0TdkyvEeObF6ELIGKT-g" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_re0Td0yvEeObF6ELIGKT-g" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_re0TeEyvEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_re0TeUyvEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_re0TekyvEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_re0Te0yvEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_re0TfEyvEeObF6ELIGKT-g" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_re0TfUyvEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_re0TfkyvEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_re0Tf0yvEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_re0TgEyvEeObF6ELIGKT-g"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_re06gEyvEeObF6ELIGKT-g" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_re06gUyvEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_re06gkyvEeObF6ELIGKT-g"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_re06g0yvEeObF6ELIGKT-g"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_re06hEyvEeObF6ELIGKT-g"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rezFUEyvEeObF6ELIGKT-g"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rezsYUyvEeObF6ELIGKT-g" x="-90" y="780" width="350"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_uPIkIUydEeObF6ELIGKT-g"/>
+    <element xmi:type="uml:Package" href="architecture-v3.uml#_IygSQLZKEeK8zaQi-hvdlw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_YeFyUEygEeObF6ELIGKT-g" type="4001" source="_PH4CIEymEeObF6ELIGKT-g" target="_AeBEgEygEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_YeHngEygEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_YeHngUygEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_YeHngkygEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_YeHng0ygEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_YeIOkEygEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_YeIOkUygEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_YeIOkkygEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_YeI1oEygEeObF6ELIGKT-g" x="-1" y="101"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_YeI1oUygEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_YeI1okygEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_YeI1o0ygEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_YeJcsEygEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_YeFyUUygEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_YeA50EygEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YeFyUkygEeObF6ELIGKT-g" points="[4, -7, -156, 0]$[147, -9, -13, -2]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YeWRAEygEeObF6ELIGKT-g" id="(0.08962264150943396,0.967741935483871)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YeWRAUygEeObF6ELIGKT-g" id="(0.14285714285714285,0.013888888888888888)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_ZFLAcEygEeObF6ELIGKT-g" type="4001" source="_z8-QsEydEeObF6ELIGKT-g" target="_CpYI0EygEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZFMOkEygEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZFMOkUygEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZFMOkkygEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZFMOk0ygEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZFMOlEygEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZFMOlUygEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZFMOlkygEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZFMOl0ygEeObF6ELIGKT-g" x="-64" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZFM1oEygEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZFM1oUygEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZFM1okygEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZFM1o0ygEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_ZFLAcUygEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_ZFGvAEygEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_ZFLAckygEeObF6ELIGKT-g" points="[7, 4, -150, 0]$[150, 3, -7, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ZFTjUEygEeObF6ELIGKT-g" id="(0.9779005524861878,0.3065868263473054)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ZFTjUUygEeObF6ELIGKT-g" id="(0.021212121212121213,0.45121951219512196)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_Q_dEQEylEeObF6ELIGKT-g" type="4001" source="_LOaSsEylEeObF6ELIGKT-g" target="_NvUJMEylEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Q_e5cEylEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Q_e5cUylEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Q_e5ckylEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Q_fggEylEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Q_fggUylEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Q_fggkylEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Q_fgg0ylEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Q_gHkEylEeObF6ELIGKT-g" x="-11" y="22"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Q_gHkUylEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Q_gHkkylEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Q_gHk0ylEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Q_guoEylEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Q_dEQUylEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_3h0tAM9VEeKO_rl5MA6s9A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Q_dEQkylEeObF6ELIGKT-g" points="[1, -50, -9, 218]$[8, -218, -2, 50]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_ULBBUEylEeObF6ELIGKT-g" type="4001" source="_z8-QsEydEeObF6ELIGKT-g" target="_LOaSsEylEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_ULBBU0ylEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ULBBVEylEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ULBBVUylEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ULBBVkylEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ULBBV0ylEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ULBoYEylEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ULBoYUylEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ULBoYkylEeObF6ELIGKT-g" x="-17" y="22"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ULBoY0ylEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ULBoZEylEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ULBoZUylEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ULBoZkylEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_ULBBUUylEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_UK_MI0ylEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_ULBBUkylEeObF6ELIGKT-g" points="[-9, -4, 150, 0]$[-155, -5, 4, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ULIWEEylEeObF6ELIGKT-g" id="(0.055248618784530384,0.4338138925294889)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ULIWEUylEeObF6ELIGKT-g" id="(0.96,0.44)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_9fKpkEymEeObF6ELIGKT-g" type="4001" source="_iIwHgEylEeObF6ELIGKT-g" target="_7ths0EymEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_9fL3sEymEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9fMewEymEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9fMewUymEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9fMewkymEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9fMew0ymEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9fNF0EymEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9fNF0UymEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9fNF0kymEeObF6ELIGKT-g" x="-9" y="62"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9fNF00ymEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9fNs4EymEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_9fNs4UymEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_9fNs4kymEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_9fKpkUymEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_9fFKAEymEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_9fKpkkymEeObF6ELIGKT-g" points="[-9, -5, 0, 70]$[-10, -67, -1, 8]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_9fcWYEymEeObF6ELIGKT-g" id="(0.4326647564469914,0.034722222222222224)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_9fcWYUymEeObF6ELIGKT-g" id="(0.46,0.92)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_JsosAEynEeObF6ELIGKT-g" type="4002" source="_NNIMsEymEeObF6ELIGKT-g" target="_iIwHgEylEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_JsqhMEynEeObF6ELIGKT-g" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_JsqhMUynEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_JsosAUynEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_JsQRgEynEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_JsosAkynEeObF6ELIGKT-g" points="[9, 2, -180, -44]$[188, 45, -1, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_JsxO4EynEeObF6ELIGKT-g" id="(0.957345971563981,0.42)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_JsxO4UynEeObF6ELIGKT-g" id="(0.0028653295128939827,0.4027777777777778)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_KWYzoEynEeObF6ELIGKT-g" type="4002" source="_PH4CIEymEeObF6ELIGKT-g" target="_iIwHgEylEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_KWao0EynEeObF6ELIGKT-g" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_KWao0UynEeObF6ELIGKT-g" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_KWYzoUynEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_KWW-cEynEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_KWYzokynEeObF6ELIGKT-g" points="[7, -2, -188, 41]$[185, -43, -10, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_KWjywEynEeObF6ELIGKT-g" id="(0.9669811320754716,0.36)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_KWjywUynEeObF6ELIGKT-g" id="(0.02865329512893983,0.5833333333333334)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_S_hzsEynEeObF6ELIGKT-g" type="4001" source="_z8-QsEydEeObF6ELIGKT-g" target="_hYeEoEymEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_S_iawEynEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S_iawUynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S_iawkynEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S_iaw0ynEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S_iaxEynEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S_jB0EynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S_jB0UynEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S_jB0kynEeObF6ELIGKT-g" x="-58" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S_jB00ynEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S_jB1EynEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S_jB1UynEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S_jB1kynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_S_hzsUynEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_S_btEEynEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_S_hzskynEeObF6ELIGKT-g" points="[3, 6, -237, 0]$[236, 5, -4, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_S_qWkEynEeObF6ELIGKT-g" id="(0.9779005524861878,0.5245508982035928)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_S_qWkUynEeObF6ELIGKT-g" id="(0.012084592145015106,0.4305555555555556)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_m-nYUEynEeObF6ELIGKT-g" type="4001" source="_z8-QsEydEeObF6ELIGKT-g" target="_PH4CIEymEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_m-pNgEynEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_m-pNgUynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_m-pNgkynEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_m-p0kEynEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_m-p0kUynEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_m-p0kkynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_m-p0k0ynEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_m-qboEynEeObF6ELIGKT-g" x="-59" y="19"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_m-qboUynEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_m-qbokynEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_m-qbo0ynEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_m-rCsEynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_m-nYUUynEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_m-if0EynEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_m-nYUkynEeObF6ELIGKT-g" points="[6, -2, -248, 0]$[245, -6, -9, -4]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_m-zlkEynEeObF6ELIGKT-g" id="(0.9668508287292817,0.8872870249017037)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_m-zlkUynEeObF6ELIGKT-g" id="(0.04245283018867924,0.08)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_pSwlMEynEeObF6ELIGKT-g" type="4001" source="_z8-QsEydEeObF6ELIGKT-g" target="_PH4CIEymEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_pSyaYEynEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pSyaYUynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pSyaYkynEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pSyaY0ynEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pSzBcEynEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pSzBcUynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pSzBckynEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pSzBc0ynEeObF6ELIGKT-g" x="-49" y="17"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pSzogEynEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pSzogUynEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pSzogkynEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pS0PkEynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_pSwlMUynEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_pSsTwEynEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_pSwlMkynEeObF6ELIGKT-g" points="[4, 3, -245, 0]$[243, 4, -6, 1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_pS_OsEynEeObF6ELIGKT-g" id="(0.9834254143646409,0.9760479041916168)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_pS_OsUynEeObF6ELIGKT-g" id="(0.02830188679245283,0.7)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_0WfYYEynEeObF6ELIGKT-g" type="4001" source="_z8-QsEydEeObF6ELIGKT-g" target="_NNIMsEymEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_0WgmgEynEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_0WgmgUynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_0WgmgkynEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_0WhNkEynEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_0WhNkUynEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_0WhNkkynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_0Wh0oEynEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_0Wh0oUynEeObF6ELIGKT-g" x="-42" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_0Wh0okynEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_0Wh0o0ynEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_0WibsEynEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_0WibsUynEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_0WfYYUynEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_0Waf4EynEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_0WfYYkynEeObF6ELIGKT-g" points="[2, 4, -241, 0]$[241, 3, -2, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_0WxsQEynEeObF6ELIGKT-g" id="(0.988950276243094,0.7365661861074705)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_0WxsQUynEeObF6ELIGKT-g" id="(0.004739336492890996,0.4032258064516129)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_x4gWMEyrEeObF6ELIGKT-g" type="4001" source="_NNIMsEymEeObF6ELIGKT-g" target="_i4LxoEyrEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_x4hkUEyrEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_x4hkUUyrEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_x4iLYEyrEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_x4iLYUyrEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_x4iLYkyrEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_x4iycEyrEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_x4iycUyrEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_x4iyckyrEeObF6ELIGKT-g" x="-32" y="43"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_x4iyc0yrEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_x4iydEyrEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_x4jZgEyrEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_x4jZgUyrEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_x4gWMUyrEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_x4cEwEyrEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_x4gWMkyrEeObF6ELIGKT-g" points="[-9, -5, 668, 0]$[-129, -5, 548, 0]$[-673, -5, 4, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_x4-QQEyrEeObF6ELIGKT-g" id="(0.04265402843601896,0.74)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_x4-3UEyrEeObF6ELIGKT-g" id="(0.9846153846153847,0.6548672566371682)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_itvxUEytEeObF6ELIGKT-g" type="4001" source="_NNIMsEymEeObF6ELIGKT-g" target="_rezsYEyvEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_itxmgEytEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_itxmgUytEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_itxmgkytEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_itxmg0ytEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ityNkEytEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ityNkUytEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ityNkkytEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ityNk0ytEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ityNlEytEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ity0oEytEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ity0oUytEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ity0okytEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_itvxUUytEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_itrf4EytEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_itvxUkytEeObF6ELIGKT-g" points="[-3, 0, 676, -82]$[-671, 80, 8, -2]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_iuA3EEytEeObF6ELIGKT-g" id="(0.014218009478672985,0.8629032258064516)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_iuA3EUytEeObF6ELIGKT-g" id="(0.9857142857142858,0.45)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_I_DJEEyuEeObF6ELIGKT-g" type="4001" source="_PH4CIEymEeObF6ELIGKT-g" target="_H2io4EyuEeObF6ELIGKT-g" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_I_EXMEyuEeObF6ELIGKT-g" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I_E-QEyuEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I_E-QUyuEeObF6ELIGKT-g" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I_E-QkyuEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I_E-Q0yuEeObF6ELIGKT-g" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I_FlUEyuEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I_FlUUyuEeObF6ELIGKT-g" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I_FlUkyuEeObF6ELIGKT-g" x="-31" y="14"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I_GMYEyuEeObF6ELIGKT-g" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I_GMYUyuEeObF6ELIGKT-g" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_I_GzcEyuEeObF6ELIGKT-g" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_I_GzcUyuEeObF6ELIGKT-g" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_I_DJEUyuEeObF6ELIGKT-g" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_I--3oEyuEeObF6ELIGKT-g"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_I_DJEkyuEeObF6ELIGKT-g" points="[2, 8, -29, -85]$[31, 93, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_I_fN8EyuEeObF6ELIGKT-g" id="(0.7296416938110749,0.9758064516129032)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_I_fN8UyuEeObF6ELIGKT-g" id="(0.06741573033707865,0.0)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_harzYFzGEeOeP67GJGKDkA" type="PapyrusUMLClassDiagram" name="regexp 2" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_q38YAFzGEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_q38YAlzGEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_q38YA1zGEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_q38YBFzGEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_q38YBVzGEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_q38YBlzGEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_q38YB1zGEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_q38YCFzGEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_q38YCVzGEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_q38YClzGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_q38YC1zGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_q38YDFzGEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_q38YDVzGEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_q38YDlzGEeOeP67GJGKDkA" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_q38YD1zGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_q38YEFzGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_q38YEVzGEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_q38YElzGEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_q38YE1zGEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_q38YFFzGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_q38YFVzGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_q38YFlzGEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_q38YF1zGEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_u6-HIM-xEeKO_rl5MA6s9A"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_q38YAVzGEeOeP67GJGKDkA" x="36" y="240"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_sdCGgFzGEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_sdCGglzGEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_sdCGg1zGEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_sdCGhFzGEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_sdCGhVzGEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_sdCGhlzGEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_sdCGh1zGEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_sdCGiFzGEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_sdCGiVzGEeOeP67GJGKDkA" type="7017">
+        <children xmi:type="notation:Shape" xmi:id="_GIp6sFzIEeOeP67GJGKDkA" type="3012" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_GIXm0FzIEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_GIp6sVzIEeOeP67GJGKDkA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_ISLL8VzIEeOeP67GJGKDkA" type="3012" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_ISLL8FzIEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_ISLL8lzIEeOeP67GJGKDkA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_oFho0FzIEeOeP67GJGKDkA" type="3012" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_oFbiMFzIEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_oFho0VzIEeOeP67GJGKDkA"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_sdCGilzGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_sdCGi1zGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_sdCGjFzGEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_sdCGjVzGEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_sdCGjlzGEeOeP67GJGKDkA" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_dUehEFzIEeOeP67GJGKDkA" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_dUYacFzIEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_dUehEVzIEeOeP67GJGKDkA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_f2mfkFzIEeOeP67GJGKDkA" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_f2gY8FzIEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_f2mfkVzIEeOeP67GJGKDkA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_kFdssVzIEeOeP67GJGKDkA" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_kFdssFzIEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_kFdsslzIEeOeP67GJGKDkA"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_sdCGj1zGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_sdCGkFzGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_sdCGkVzGEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_sdCGklzGEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_sdCGk1zGEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_sdCGlFzGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_sdCGlVzGEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_sdCGllzGEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_sdCGl1zGEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_sc15QFzGEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_sdCGgVzGEeOeP67GJGKDkA" x="402" y="198" width="223" height="196"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_rYenUFzIEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rYenUlzIEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rYenU1zIEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rYenVFzIEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rYenVVzIEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rYenVlzIEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rYenV1zIEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_rYenWFzIEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rYenWVzIEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rYenWlzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rYenW1zIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rYenXFzIEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rYenXVzIEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rYenXlzIEeOeP67GJGKDkA" type="7018">
+        <children xmi:type="notation:Shape" xmi:id="_rjKtAFzLEeOeP67GJGKDkA" type="3013" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_rjEmYFzLEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_rjKtAVzLEeOeP67GJGKDkA"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rYenX1zIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rYenYFzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rYenYVzIEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rYenYlzIEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rYenY1zIEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rYenZFzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rYenZVzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rYenZlzIEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rYenZ1zIEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_rYYgsFzIEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rYenUVzIEeOeP67GJGKDkA" x="360" y="480" width="309" height="103"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_4ZF98VzIEeOeP67GJGKDkA" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_4ZF981zIEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_4ZF99FzIEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_4ZF99VzIEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_4ZF99lzIEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_4ZMEkFzIEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_4ZMEkVzIEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_4ZMEklzIEeOeP67GJGKDkA" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_4ZMEk1zIEeOeP67GJGKDkA" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_4ZMElFzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_4ZMElVzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_4ZMEllzIEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_4ZMEl1zIEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_4ZMEmFzIEeOeP67GJGKDkA" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="__cOCcFzIEeOeP67GJGKDkA" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#__cB1MFzIEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="__cOCcVzIEeOeP67GJGKDkA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_fsK7wFzJEeOeP67GJGKDkA" type="3007" fontName="Segoe UI" lineColor="0">
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_fsE1IFzJEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_fsK7wVzJEeOeP67GJGKDkA"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_4ZMEmVzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_4ZMEmlzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_4ZMEm1zIEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_4ZMEnFzIEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_4ZMEnVzIEeOeP67GJGKDkA" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_4ZMEnlzIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_4ZMEn1zIEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_4ZMEoFzIEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_4ZMEoVzIEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_4ZF98FzIEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_4ZF98lzIEeOeP67GJGKDkA" x="744" y="24" width="166" height="127"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_hd8bYVzJEeOeP67GJGKDkA" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hd8bY1zJEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hd8bZFzJEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hd8bZVzJEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hd8bZlzJEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_hd8bZ1zJEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_hd8baFzJEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_hd8baVzJEeOeP67GJGKDkA" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hd8balzJEeOeP67GJGKDkA" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hd8ba1zJEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hd8bbFzJEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hd8bbVzJEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hd8bblzJEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hd8bb1zJEeOeP67GJGKDkA" type="7007">
+        <children xmi:type="notation:Shape" xmi:id="_-Vl8IVzJEeOeP67GJGKDkA" type="3007" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_MkylwFzKEeOeP67GJGKDkA" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_OyKcQFzKEeOeP67GJGKDkA" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_-Vl8IFzJEeOeP67GJGKDkA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_-Vl8IlzJEeOeP67GJGKDkA"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hd8bcFzJEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hd8bcVzJEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hd8bclzJEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hd8bc1zJEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_heCiAFzJEeOeP67GJGKDkA" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_heCiAVzJEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_heCiAlzJEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_heCiA1zJEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_heCiBFzJEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_hd8bYFzJEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hd8bYlzJEeOeP67GJGKDkA" x="354" y="24"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_AipCgFzKEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_AipCglzKEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_AipCg1zKEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_AipChFzKEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_AipChVzKEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_AipChlzKEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_AipCh1zKEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_AipCiFzKEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_AipCiVzKEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_AipCilzKEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_AipCi1zKEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_AipCjFzKEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AipCjVzKEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_AipCjlzKEeOeP67GJGKDkA" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_AipCj1zKEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_AipCkFzKEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_AipCkVzKEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AipCklzKEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_AipCk1zKEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_AipClFzKEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_AipClVzKEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_AipCllzKEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AipCl1zKEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_Aii74FzKEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_AipCgVzKEeOeP67GJGKDkA" x="978" y="24" height="91"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_SOF7IVzLEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SOMBwFzLEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SOMBwVzLEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SOMBwlzLEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SOMBw1zLEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SOMBxFzLEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SOMBxVzLEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_SOMBxlzLEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SOMBx1zLEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SOMByFzLEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SOMByVzLEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SOMBylzLEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SOMBy1zLEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SOMBzFzLEeOeP67GJGKDkA" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SOMBzVzLEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SOMBzlzLEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SOMBz1zLEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SOMB0FzLEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SOMB0VzLEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SOMB0lzLEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SOMB01zLEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SOMB1FzLEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SOMB1VzLEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_SOF7IFzLEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SOF7IlzLEeOeP67GJGKDkA" x="774" y="486"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_mPYCsFzMEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_mPYCslzMEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_mPYCs1zMEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_mPYCtFzMEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_mPYCtVzMEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_mPYCtlzMEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_mPYCt1zMEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_mPYCuFzMEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_mPYCuVzMEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_mPYCulzMEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_mPYCu1zMEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_mPYCvFzMEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_mPYCvVzMEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_mPYCvlzMEeOeP67GJGKDkA" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_mPYCv1zMEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_mPYCwFzMEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_mPYCwVzMEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_mPYCwlzMEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_mPYCw1zMEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_mPYCxFzMEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_mPYCxVzMEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_mPYCxlzMEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_mPYCx1zMEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_j52EYNIUEeKovM8ingMMQQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_mPYCsVzMEeOeP67GJGKDkA" x="864" y="228" width="175"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_G6_u4FzOEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_G6_u4lzOEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_G6_u41zOEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_G6_u5FzOEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_G6_u5VzOEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_G6_u5lzOEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_G6_u51zOEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_G6_u6FzOEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_G6_u6VzOEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_G6_u6lzOEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_G6_u61zOEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_G6_u7FzOEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_G6_u7VzOEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_G6_u7lzOEeOeP67GJGKDkA" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_G6_u71zOEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_G6_u8FzOEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_G6_u8VzOEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_G6_u8lzOEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_G6_u81zOEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_G6_u9FzOEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_G6_u9VzOEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_G6_u9lzOEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_G6_u91zOEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_G65oQFzOEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_G6_u4VzOEeOeP67GJGKDkA" x="702" y="168" height="49"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_harzYVzGEeOeP67GJGKDkA"/>
+    <element xmi:type="uml:Model" href="architecture-v3.uml#_bAQtoFzGEeOeP67GJGKDkA"/>
+    <edges xmi:type="notation:Connector" xmi:id="_pR38pFzHEeOeP67GJGKDkA" type="4001" source="_q38YAFzGEeOeP67GJGKDkA" target="_sdCGgFzGEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_pR38p1zHEeOeP67GJGKDkA" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pR38qFzHEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pR38qVzHEeOeP67GJGKDkA" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pR38qlzHEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pR38q1zHEeOeP67GJGKDkA" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pR38rFzHEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pR38rVzHEeOeP67GJGKDkA" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pR38rlzHEeOeP67GJGKDkA" x="-48" y="25"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pR38r1zHEeOeP67GJGKDkA" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pR38sFzHEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pR38sVzHEeOeP67GJGKDkA" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pR38slzHEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_pR38pVzHEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_pR38oFzHEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_pR38plzHEeOeP67GJGKDkA" points="[6, 5, -214, 0]$[212, 5, -8, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_pSEJ4FzHEeOeP67GJGKDkA" id="(0.94,0.52)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_pSEJ4VzHEeOeP67GJGKDkA" id="(0.05517241379310345,0.51)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_vW8LgFzJEeOeP67GJGKDkA" type="4003" source="_sdCGgFzGEeOeP67GJGKDkA" target="_hd8bYVzJEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_vW8Lg1zJEeOeP67GJGKDkA" visible="false" type="6008">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vW8LhFzJEeOeP67GJGKDkA" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_vW8LhVzJEeOeP67GJGKDkA" visible="false" type="6009">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_vW8LhlzJEeOeP67GJGKDkA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_vW8LgVzJEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:InterfaceRealization" href="architecture-v3.uml#_vWp3oFzJEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_vW8LglzJEeOeP67GJGKDkA" points="[-3, -10, 0, 61]$[-5, -65, -2, 6]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_vXCSIFzJEeOeP67GJGKDkA" id="(0.4304932735426009,0.05102040816326531)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_vXCSIVzJEeOeP67GJGKDkA" id="(0.45110410094637227,0.9838709677419355)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_Yg8ZQFzLEeOeP67GJGKDkA" type="4007" source="_4ZF98VzIEeOeP67GJGKDkA" target="_hd8bYVzJEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Yg8ZQ1zLEeOeP67GJGKDkA" visible="false" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Yg8ZRFzLEeOeP67GJGKDkA" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Yg8ZRVzLEeOeP67GJGKDkA" visible="false" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Yg8ZRlzLEeOeP67GJGKDkA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Yg8ZQVzLEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_Yg2SoFzLEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Yg8ZQlzLEeOeP67GJGKDkA" points="[-1, 4, 78, 0]$[-74, 3, 5, -1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YhCf4FzLEeOeP67GJGKDkA" id="(0.006024096385542169,0.4094488188976378)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YhCf4VzLEeOeP67GJGKDkA" id="(0.9842271293375394,0.45161290322580644)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_ZvbloVzLEeOeP67GJGKDkA" type="4007" source="_4ZF98VzIEeOeP67GJGKDkA" target="_AipCgFzKEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZvhsQFzLEeOeP67GJGKDkA" visible="false" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZvhsQVzLEeOeP67GJGKDkA" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZvhsQlzLEeOeP67GJGKDkA" visible="false" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZvhsQ1zLEeOeP67GJGKDkA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_ZvblolzLEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_ZvbloFzLEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Zvblo1zLEeOeP67GJGKDkA" points="[9, -7, -69, 0]$[77, -7, -1, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Zvny4FzLEeOeP67GJGKDkA" id="(0.9457831325301205,0.4645669291338583)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Zvny4VzLEeOeP67GJGKDkA" id="(0.007194244604316547,0.5714285714285714)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_bBitwVzLEeOeP67GJGKDkA" type="4007" source="_rYenUFzIEeOeP67GJGKDkA" target="_SOF7IVzLEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_bBo0YFzLEeOeP67GJGKDkA" visible="false" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bBo0YVzLEeOeP67GJGKDkA" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_bBo0YlzLEeOeP67GJGKDkA" visible="false" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_bBo0Y1zLEeOeP67GJGKDkA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_bBitwlzLEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_bBitwFzLEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_bBitw1zLEeOeP67GJGKDkA" points="[3, -1, -105, 0]$[108, -1, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_bBu7AFzLEeOeP67GJGKDkA" id="(0.9902912621359223,0.49514563106796117)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_bBu7AVzLEeOeP67GJGKDkA" id="(0.0,0.44)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_dTW_YFzLEeOeP67GJGKDkA" type="4001" source="_sdCGgFzGEeOeP67GJGKDkA" target="_rYenUFzIEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_dTW_Y1zLEeOeP67GJGKDkA" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_dTW_ZFzLEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_dTW_ZVzLEeOeP67GJGKDkA" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_dTW_ZlzLEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_dTW_Z1zLEeOeP67GJGKDkA" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_dTW_aFzLEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_dTW_aVzLEeOeP67GJGKDkA" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_dTW_alzLEeOeP67GJGKDkA" x="-13" y="166"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_dTW_a1zLEeOeP67GJGKDkA" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_dTW_bFzLEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_dTW_bVzLEeOeP67GJGKDkA" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_dTW_blzLEeOeP67GJGKDkA" x="-7" y="-23"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_dTW_YVzLEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_dTQ4wFzLEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_dTW_YlzLEeOeP67GJGKDkA" points="[-1, 5, 0, -41]$[-2, 43, -1, -3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_dTdGAFzLEeOeP67GJGKDkA" id="(0.49327354260089684,0.9744897959183674)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_dTdGAVzLEeOeP67GJGKDkA" id="(0.4886731391585761,0.02912621359223301)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_yKcjAFzLEeOeP67GJGKDkA" type="4001" source="_SOF7IVzLEeOeP67GJGKDkA" target="_sdCGgFzGEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_yKcjA1zLEeOeP67GJGKDkA" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_yKcjBFzLEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_yKcjBVzLEeOeP67GJGKDkA" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_yKcjBlzLEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_yKcjB1zLEeOeP67GJGKDkA" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_yKcjCFzLEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_yKcjCVzLEeOeP67GJGKDkA" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_yKcjClzLEeOeP67GJGKDkA" x="-21" y="21"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_yKcjC1zLEeOeP67GJGKDkA" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_yKcjDFzLEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_yKcjDVzLEeOeP67GJGKDkA" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_yKcjDlzLEeOeP67GJGKDkA" x="13" y="-21"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_yKcjAVzLEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_yKWcY1zLEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_yKcjAlzLEeOeP67GJGKDkA" points="[6, 0, 188, 149]$[6, -149, 188, 0]$[-173, -149, 9, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_yKowQFzLEeOeP67GJGKDkA" id="(0.08571428571428572,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_yKowQVzLEeOeP67GJGKDkA" id="(0.9596412556053812,0.7091836734693877)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_oS7O11zMEeOeP67GJGKDkA" type="4001" source="_SOF7IVzLEeOeP67GJGKDkA" target="_mPYCsFzMEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_oTBVcFzMEeOeP67GJGKDkA" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_oTBVcVzMEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_oTBVclzMEeOeP67GJGKDkA" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_oTBVc1zMEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_oTBVdFzMEeOeP67GJGKDkA" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_oTBVdVzMEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_oTBVdlzMEeOeP67GJGKDkA" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_oTBVd1zMEeOeP67GJGKDkA" x="-18" y="4"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_oTBVeFzMEeOeP67GJGKDkA" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_oTBVeVzMEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_oTBVelzMEeOeP67GJGKDkA" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_oTBVe1zMEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_oS7O2FzMEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_oS7O01zMEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_oS7O2VzMEeOeP67GJGKDkA" points="[1, -8, -32, 208]$[25, -166, -8, 50]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_oTHcEFzMEeOeP67GJGKDkA" id="(0.46785714285714286,0.08)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_BqhJMFzNEeOeP67GJGKDkA" id="(0.2342857142857143,0.41)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_o7viV1zMEeOeP67GJGKDkA" type="4001" source="_SOF7IVzLEeOeP67GJGKDkA" target="_mPYCsFzMEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_o71o8FzMEeOeP67GJGKDkA" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_o71o8VzMEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_o71o8lzMEeOeP67GJGKDkA" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_o71o81zMEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_o71o9FzMEeOeP67GJGKDkA" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_o71o9VzMEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_o71o9lzMEeOeP67GJGKDkA" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_o71o91zMEeOeP67GJGKDkA" x="-18" y="35"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_o71o-FzMEeOeP67GJGKDkA" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_o71o-VzMEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_o71o-lzMEeOeP67GJGKDkA" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_o71o-1zMEeOeP67GJGKDkA" x="6" y="23"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_o7viWFzMEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_o7viU1zMEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_o7viWVzMEeOeP67GJGKDkA" points="[-1, -2, 65, 208]$[-16, -173, 50, 37]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_o8B2MFzMEeOeP67GJGKDkA" id="(0.8214285714285714,0.02)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_A2nnEFzNEeOeP67GJGKDkA" id="(0.8342857142857143,0.44)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_IDbzEFzNEeOeP67GJGKDkA" type="4001" source="_sdCGgFzGEeOeP67GJGKDkA" target="_mPYCsFzMEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_IDbzE1zNEeOeP67GJGKDkA" visible="false" type="6001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_IDbzFFzNEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_IDbzFVzNEeOeP67GJGKDkA" visible="false" type="6002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_IDbzFlzNEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_IDbzF1zNEeOeP67GJGKDkA" visible="false" type="6003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_IDbzGFzNEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_IDbzGVzNEeOeP67GJGKDkA" type="6005">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_IDbzGlzNEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_IDbzG1zNEeOeP67GJGKDkA" visible="false" type="6033">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_IDbzHFzNEeOeP67GJGKDkA" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_IDbzHVzNEeOeP67GJGKDkA" type="6034">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_IDbzHlzNEeOeP67GJGKDkA" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_IDbzEVzNEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="architecture-v3.uml#_IDVsc1zNEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_IDbzElzNEeOeP67GJGKDkA" points="[3, -6, -250, 0]$[242, -11, -11, -5]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_IDuG8FzNEeOeP67GJGKDkA" id="(0.9865470852017937,0.2857142857142857)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_IDuG8VzNEeOeP67GJGKDkA" id="(0.06285714285714286,0.2)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_PlHmYVzOEeOeP67GJGKDkA" type="4007" source="_IDbzEFzNEeOeP67GJGKDkA" target="_G6_u4FzOEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_PlHmZFzOEeOeP67GJGKDkA" visible="false" type="6016">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PlHmZVzOEeOeP67GJGKDkA" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PlHmZlzOEeOeP67GJGKDkA" visible="false" type="6017">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_PlHmZ1zOEeOeP67GJGKDkA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_PlHmYlzOEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Usage" href="architecture-v3.uml#_PlHmYFzOEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_PlHmY1zOEeOeP67GJGKDkA" points="[1, 0, 0, 36]$[0, -31, -1, 5]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_PlNtAFzOEeOeP67GJGKDkA" id="(0.5164179104477612,0.47674418604651164)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_PlNtAVzOEeOeP67GJGKDkA" id="(0.47,0.9090909090909091)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_HLcwQFzPEeOeP67GJGKDkA" type="PapyrusUMLClassDiagram" name="regexp::ModelChangedNotifier" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_IWgOIFzPEeOeP67GJGKDkA" type="2004" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IWgOIlzPEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IWgOI1zPEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IWgOJFzPEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IWgOJVzPEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IWgOJlzPEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IWgOJ1zPEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_IWgOKFzPEeOeP67GJGKDkA" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_IWgOKVzPEeOeP67GJGKDkA" type="7006">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_IWgOKlzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_IWgOK1zPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_IWgOLFzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IWgOLVzPEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_IWgOLlzPEeOeP67GJGKDkA" type="7007">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_IWgOL1zPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_IWgOMFzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_IWgOMVzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IWgOMlzPEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_IWmUwFzPEeOeP67GJGKDkA" type="7008">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_IWmUwVzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_IWmUwlzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_IWmUw1zPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IWmUxFzPEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_4ZF98FzIEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IWgOIVzPEeOeP67GJGKDkA" x="402" y="30"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_IwYtwVzPEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IwYtw1zPEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IwYtxFzPEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IwYtxVzPEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IwYtxlzPEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IwYtx1zPEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IwYtyFzPEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_IwYtyVzPEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_IwYtylzPEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_IwYty1zPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_IwYtzFzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_IwYtzVzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IwYtzlzPEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_IwYtz1zPEeOeP67GJGKDkA" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_IwYt0FzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_IwYt0VzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_IwYt0lzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IwYt01zPEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Iwe0YFzPEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Iwe0YVzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Iwe0YlzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Iwe0Y1zPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Iwe0ZFzPEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_IwYtwFzPEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IwYtwlzPEeOeP67GJGKDkA" x="204" y="366" width="194"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_PA97AFzPEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PA97AlzPEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PA97A1zPEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PA97BFzPEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PA97BVzPEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_PA97BlzPEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_PA97B1zPEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_PA97CFzPEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_PA97CVzPEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_PA97ClzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_PA97C1zPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_PA97DFzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PA97DVzPEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_PA97DlzPEeOeP67GJGKDkA" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_PA97D1zPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_PA97EFzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_PA97EVzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PA97ElzPEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_PA97E1zPEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_PA97FFzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_PA97FVzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_PA97FlzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PA97F1zPEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_PA30YFzPEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_PA97AVzPEeOeP67GJGKDkA" x="588" y="366" width="151"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_SNeTQVzPEeOeP67GJGKDkA" type="2008" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SNeTQ1zPEeOeP67GJGKDkA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SNeTRFzPEeOeP67GJGKDkA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SNeTRVzPEeOeP67GJGKDkA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SNeTRlzPEeOeP67GJGKDkA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SNeTR1zPEeOeP67GJGKDkA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SNeTSFzPEeOeP67GJGKDkA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_SNeTSVzPEeOeP67GJGKDkA" type="5029"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SNeTSlzPEeOeP67GJGKDkA" type="7017">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SNeTS1zPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SNeTTFzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SNeTTVzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SNeTTlzPEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SNeTT1zPEeOeP67GJGKDkA" type="7018">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SNeTUFzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SNeTUVzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SNeTUlzPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SNeTU1zPEeOeP67GJGKDkA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_SNeTVFzPEeOeP67GJGKDkA" type="7019">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_SNeTVVzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_SNeTVlzPEeOeP67GJGKDkA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_SNeTV1zPEeOeP67GJGKDkA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SNeTWFzPEeOeP67GJGKDkA"/>
+      </children>
+      <element xmi:type="uml:Class" href="architecture-v3.uml#_SNeTQFzPEeOeP67GJGKDkA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SNeTQlzPEeOeP67GJGKDkA" x="348" y="182" width="230"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_HLcwQVzPEeOeP67GJGKDkA"/>
+    <element xmi:type="uml:Model" href="architecture-v3.uml#_bAQtoFzGEeOeP67GJGKDkA"/>
+    <edges xmi:type="notation:Connector" xmi:id="_R09soVzPEeOeP67GJGKDkA" type="4003" source="_SNeTQVzPEeOeP67GJGKDkA" target="_IWgOIFzPEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_R09spFzPEeOeP67GJGKDkA" type="6008">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_R09spVzPEeOeP67GJGKDkA" y="40"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_R09splzPEeOeP67GJGKDkA" type="6009">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_R09sp1zPEeOeP67GJGKDkA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_R09solzPEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:InterfaceRealization" href="architecture-v3.uml#_R09soFzPEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_R09so1zPEeOeP67GJGKDkA" points="[-10, -6, 134, 82]$[-142, -81, 2, 7]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_R1J54FzPEeOeP67GJGKDkA" id="(0.6652173913043479,0.09)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_R1J54VzPEeOeP67GJGKDkA" id="(0.620253164556962,0.9380530973451328)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_Y_ZTAFzPEeOeP67GJGKDkA" type="4002" source="_IwYtwVzPEeOeP67GJGKDkA" target="_SNeTQVzPEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Y_ZTA1zPEeOeP67GJGKDkA" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Y_ZTBFzPEeOeP67GJGKDkA" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Y_ZTAVzPEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_Y_TMYFzPEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Y_ZTAlzPEeOeP67GJGKDkA" points="[6, -2, -148, 48]$[150, -44, -4, 6]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Y_fZoFzPEeOeP67GJGKDkA" id="(0.6494845360824743,0.02)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Y_fZoVzPEeOeP67GJGKDkA" id="(0.3826086956521739,0.94)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_ZwmtgVzPEeOeP67GJGKDkA" type="4002" source="_PA97AFzPEeOeP67GJGKDkA" target="_SNeTQVzPEeOeP67GJGKDkA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZwmthFzPEeOeP67GJGKDkA" type="6007">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZwmthVzPEeOeP67GJGKDkA" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_ZwmtglzPEeOeP67GJGKDkA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="architecture-v3.uml#_ZwmtgFzPEeOeP67GJGKDkA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Zwmtg1zPEeOeP67GJGKDkA" points="[-34, -10, 146, 43]$[-173, -42, 7, 11]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Zwy6wFzPEeOeP67GJGKDkA" id="(0.3841059602649007,0.1)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Zwy6wVzPEeOeP67GJGKDkA" id="(0.6173913043478261,0.89)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_uQQgIXh8EeOlpfB_tZS-QA" type="PapyrusUMLStateMachineDiagram" name="Layers Life Cycle" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_uQQgInh8EeOlpfB_tZS-QA" type="2000" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uQQgI3h8EeOlpfB_tZS-QA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uQQgJHh8EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uQQgJXh8EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uQQgJnh8EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uQQgJ3h8EeOlpfB_tZS-QA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uQQgKHh8EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uQQgKXh8EeOlpfB_tZS-QA" type="2001">
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uQQgKnh8EeOlpfB_tZS-QA" width="847" height="25"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_uQQgK3h8EeOlpfB_tZS-QA" type="2002">
+        <children xmi:type="notation:Shape" xmi:id="_uQQgLHh8EeOlpfB_tZS-QA" type="3000" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uQQgLXh8EeOlpfB_tZS-QA" source="ShadowFigure">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uQQgLnh8EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uQQgL3h8EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uQQgMHh8EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uQQgMXh8EeOlpfB_tZS-QA" source="QualifiedName">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uQQgMnh8EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_uQQgM3h8EeOlpfB_tZS-QA" source="RegionAnnotationKey">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_uQQgNHh8EeOlpfB_tZS-QA" key="RegionZoneKey" value=""/>
+          </eAnnotations>
+          <children xmi:type="notation:DecorationNode" xmi:id="_uQQgNXh8EeOlpfB_tZS-QA" type="3002">
+            <children xmi:type="notation:Shape" xmi:id="_vdmdAHh8EeOlpfB_tZS-QA" type="8000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vdmdAnh8EeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vdmdA3h8EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vdmdBHh8EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vdmdBXh8EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_vdmdBnh8EeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_vdmdB3h8EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_vdmdCHh8EeOlpfB_tZS-QA" type="8001">
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_vdmdCXh8EeOlpfB_tZS-QA" x="-18" y="-30"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_vdmdCnh8EeOlpfB_tZS-QA" type="8002">
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_vdmdC3h8EeOlpfB_tZS-QA" x="25" y="-10"/>
+              </children>
+              <element xmi:type="uml:Pseudostate" href="architecture-v3.uml#_vdgWYHh8EeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_vdmdAXh8EeOlpfB_tZS-QA" x="24" y="131"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_wpIcAXh8EeOlpfB_tZS-QA" type="6000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_wpIcA3h8EeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_wpIcBHh8EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_wpIcBXh8EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_wpIcBnh8EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_wpIcB3h8EeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_wpIcCHh8EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_wpIcCXh8EeOlpfB_tZS-QA" type="6001">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_0CYPwHh8EeOlpfB_tZS-QA" width="73"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_wpIcCnh8EeOlpfB_tZS-QA" visible="false" type="6002">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_wpIcC3h8EeOlpfB_tZS-QA" y="-1" width="73"/>
+              </children>
+              <element xmi:type="uml:State" href="architecture-v3.uml#_wpIcAHh8EeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_wpIcAnh8EeOlpfB_tZS-QA" x="192" y="119" width="73"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_1MAKQHh8EeOlpfB_tZS-QA" type="6000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1MAKQnh8EeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1MAKQ3h8EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1MAKRHh8EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1MAKRXh8EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_1MAKRnh8EeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_1MAKR3h8EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_1MAKSHh8EeOlpfB_tZS-QA" type="6001">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_4om0AHh8EeOlpfB_tZS-QA" width="73"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_1MAKSXh8EeOlpfB_tZS-QA" visible="false" type="6002">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_1MAKSnh8EeOlpfB_tZS-QA" y="-1" width="73"/>
+              </children>
+              <element xmi:type="uml:State" href="architecture-v3.uml#_1L6DoHh8EeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_1MAKQXh8EeOlpfB_tZS-QA" x="186" y="287" width="73"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_5CvLQXh8EeOlpfB_tZS-QA" type="6000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_5CvLQ3h8EeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_5CvLRHh8EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_5CvLRXh8EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_5CvLRnh8EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_5CvLR3h8EeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_5CvLSHh8EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_5CvLSXh8EeOlpfB_tZS-QA" type="6001">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8b-_AHh8EeOlpfB_tZS-QA" width="87"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_5CvLSnh8EeOlpfB_tZS-QA" visible="false" type="6002">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_5CvLS3h8EeOlpfB_tZS-QA" y="-1" width="87"/>
+              </children>
+              <element xmi:type="uml:State" href="architecture-v3.uml#_5CvLQHh8EeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_5CvLQnh8EeOlpfB_tZS-QA" x="474" y="197" width="87"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_88ymAHh8EeOlpfB_tZS-QA" type="6000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_88ymAnh8EeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_88ymA3h8EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_88ymBHh8EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_88ymBXh8EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_88ymBnh8EeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_88ymB3h8EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_88ymCHh8EeOlpfB_tZS-QA" type="6001">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_-DXMgHh8EeOlpfB_tZS-QA" width="93"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_88ymCXh8EeOlpfB_tZS-QA" visible="false" type="6002">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_88ymCnh8EeOlpfB_tZS-QA" y="-1" width="93"/>
+              </children>
+              <element xmi:type="uml:State" href="architecture-v3.uml#_88sfYHh8EeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_88ymAXh8EeOlpfB_tZS-QA" x="474" y="365" width="93"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_A8n4oHh9EeOlpfB_tZS-QA" type="666" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A8n4o3h9EeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_A8n4pHh9EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A8n4pXh9EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_A8n4pnh9EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A8n4p3h9EeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_A8n4qHh9EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_A8n4qXh9EeOlpfB_tZS-QA" type="6666"/>
+              <styles xmi:type="notation:HintedDiagramLinkStyle" xmi:id="_A8n4oXh9EeOlpfB_tZS-QA"/>
+              <element xmi:type="uml:Comment" href="architecture-v3.uml#_A8brYHh9EeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_A8n4onh9EeOlpfB_tZS-QA" x="636" y="65"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_SOzyIHh9EeOlpfB_tZS-QA" type="8000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SOzyInh9EeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SOzyI3h9EeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SOzyJHh9EeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SOzyJXh9EeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_SOzyJnh9EeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_SOzyJ3h9EeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_SOzyKHh9EeOlpfB_tZS-QA" type="8001">
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_SOzyKXh9EeOlpfB_tZS-QA" x="-17" y="-31"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_SOzyKnh9EeOlpfB_tZS-QA" type="8002">
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_SOzyK3h9EeOlpfB_tZS-QA" x="25" y="-10"/>
+              </children>
+              <element xmi:type="uml:Pseudostate" href="architecture-v3.uml#_SOtrgHh9EeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_SOzyIXh9EeOlpfB_tZS-QA" x="23" y="288"/>
+            </children>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uQQgNnh8EeOlpfB_tZS-QA"/>
+          </children>
+          <element xmi:type="uml:Region" href="architecture-v3.uml#_uQQgIHh8EeOlpfB_tZS-QA"/>
+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uQQgN3h8EeOlpfB_tZS-QA" width="847" height="516"/>
+        </children>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uQQgOHh8EeOlpfB_tZS-QA" y="25" width="847" height="516"/>
+      </children>
+      <element xmi:type="uml:StateMachine" href="architecture-v3.uml#_sqYugHh8EeOlpfB_tZS-QA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uQQgOXh8EeOlpfB_tZS-QA" x="30" y="30" width="847" height="541"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_uQQgOnh8EeOlpfB_tZS-QA"/>
+    <element xmi:type="uml:StateMachine" href="architecture-v3.uml#_sqYugHh8EeOlpfB_tZS-QA"/>
+    <edges xmi:type="notation:Connector" xmi:id="_PmKU4Hh9EeOlpfB_tZS-QA" type="667" source="_A8n4oHh9EeOlpfB_tZS-QA" target="_5CvLQXh8EeOlpfB_tZS-QA" lineColor="0">
+      <styles xmi:type="notation:FontStyle" xmi:id="_PmKU4Xh9EeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xsi:nil="true"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_PmKU4nh9EeOlpfB_tZS-QA" points="[-9, 3, 58, -24]$[-54, 23, 13, -4]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_PmWiIHh9EeOlpfB_tZS-QA" id="(0.05,0.6388888888888888)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_PmWiIXh9EeOlpfB_tZS-QA" id="(0.8505747126436781,0.3)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_QziuAHh9EeOlpfB_tZS-QA" type="7000" source="_vdmdAHh8EeOlpfB_tZS-QA" target="_wpIcAXh8EeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_QziuA3h9EeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_QziuBHh9EeOlpfB_tZS-QA" x="-9" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_QziuBXh9EeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_QziuBnh9EeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_QziuB3h9EeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_QziuCHh9EeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_QziuAXh9EeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_QzWgwHh9EeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_QziuAnh9EeOlpfB_tZS-QA" points="[10, 4, -117, -49]$[121, 51, -6, -2]"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Qzu7QHh9EeOlpfB_tZS-QA" id="(0.0821917808219178,0.35)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_T3VPIHh9EeOlpfB_tZS-QA" type="7000" source="_SOzyIHh9EeOlpfB_tZS-QA" target="_1MAKQHh8EeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_T3VPI3h9EeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_T3VPJHh9EeOlpfB_tZS-QA" x="-6" y="17"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_T3VPJXh9EeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_T3VPJnh9EeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_T3VPJ3h9EeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_T3VPKHh9EeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_T3VPIXh9EeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_T3PIgHh9EeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_T3VPInh9EeOlpfB_tZS-QA" points="[10, 6, -149, 0]$[153, 5, -6, -1]"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_T3hcYHh9EeOlpfB_tZS-QA" id="(0.0821917808219178,0.425)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_Wz_NgHh9EeOlpfB_tZS-QA" type="7000" source="_5CvLQXh8EeOlpfB_tZS-QA" target="_88ymAHh8EeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Wz_Ng3h9EeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_W0FUIHh9EeOlpfB_tZS-QA" x="-10" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_W0FUIXh9EeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_W0FUInh9EeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_W0FUI3h9EeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_W0FUJHh9EeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Wz_NgXh9EeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_Wz5G4Hh9EeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Wz_Ngnh9EeOlpfB_tZS-QA" points="[0, 4, -22, -110]$[9, 108, -13, -6]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_W0FUJXh9EeOlpfB_tZS-QA" id="(0.21839080459770116,0.975)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_W0FUJnh9EeOlpfB_tZS-QA" id="(0.1827956989247312,0.15)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_X_U_QXh9EeOlpfB_tZS-QA" type="7000" source="_88ymAHh8EeOlpfB_tZS-QA" target="_5CvLQXh8EeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_X_U_RHh9EeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_X_U_RXh9EeOlpfB_tZS-QA" x="-38" y="48"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_X_U_Rnh9EeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_X_U_R3h9EeOlpfB_tZS-QA" x="-8" y="37"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_X_U_SHh9EeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_X_U_SXh9EeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_X_U_Qnh9EeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_X_U_QHh9EeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_X_U_Q3h9EeOlpfB_tZS-QA" points="[-3, -8, 37, 114]$[-28, -119, 12, 3]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_X_nTIHh9EeOlpfB_tZS-QA" id="(0.8494623655913979,0.2)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_X_nTIXh9EeOlpfB_tZS-QA" id="(0.8620689655172413,0.75)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_ZpaigHh9EeOlpfB_tZS-QA" type="7000" source="_wpIcAXh8EeOlpfB_tZS-QA" target="_5CvLQXh8EeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Zpaig3h9EeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZpaihHh9EeOlpfB_tZS-QA" x="-23" y="-18"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_ZpaihXh9EeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Zpaihnh9EeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Zpaih3h9EeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_ZpaiiHh9EeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_ZpaigXh9EeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_ZpOVQHh9EeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Zpaignh9EeOlpfB_tZS-QA" points="[10, 1, -218, -28]$[225, 29, -3, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ZpgpIHh9EeOlpfB_tZS-QA" id="(0.863013698630137,0.525)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_ZpgpIXh9EeOlpfB_tZS-QA" id="(0.034482758620689655,0.5)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_a0RzIHh9EeOlpfB_tZS-QA" type="7000" source="_1MAKQHh8EeOlpfB_tZS-QA" target="_5CvLQXh8EeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_a0RzI3h9EeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_a0RzJHh9EeOlpfB_tZS-QA" x="-14" y="-1"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_a0RzJXh9EeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_a0RzJnh9EeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_a0RzJ3h9EeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_a0RzKHh9EeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_a0RzIXh9EeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_a0LsgHh9EeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_a0RzInh9EeOlpfB_tZS-QA" points="[8, -5, -225, 116]$[229, -120, -4, 1]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_a0eAYHh9EeOlpfB_tZS-QA" id="(0.8904109589041096,0.375)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_a0eAYXh9EeOlpfB_tZS-QA" id="(0.04597701149425287,0.8)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_GqKscXiMEeOlpfB_tZS-QA" type="PapyrusUMLStateMachineDiagram" name="Layer Life Cycle v2" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_GqKscniMEeOlpfB_tZS-QA" type="2000" fontName="Segoe UI" lineColor="0">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GqKsc3iMEeOlpfB_tZS-QA" source="ShadowFigure">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GqKsdHiMEeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GqKsdXiMEeOlpfB_tZS-QA" source="displayNameLabelIcon">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GqKsdniMEeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+      </eAnnotations>
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GqKsd3iMEeOlpfB_tZS-QA" source="QualifiedName">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GqKseHiMEeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+      </eAnnotations>
+      <children xmi:type="notation:DecorationNode" xmi:id="_GqKseXiMEeOlpfB_tZS-QA" type="2001">
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GqKseniMEeOlpfB_tZS-QA" width="871" height="25"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_GqKse3iMEeOlpfB_tZS-QA" type="2002">
+        <children xmi:type="notation:Shape" xmi:id="_GqKsfHiMEeOlpfB_tZS-QA" type="3000" fontName="Segoe UI" lineColor="0">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GqKsfXiMEeOlpfB_tZS-QA" source="ShadowFigure">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GqKsfniMEeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GqKsf3iMEeOlpfB_tZS-QA" source="displayNameLabelIcon">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GqKsgHiMEeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GqKsgXiMEeOlpfB_tZS-QA" source="QualifiedName">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GqKsgniMEeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+          </eAnnotations>
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GqKsg3iMEeOlpfB_tZS-QA" source="RegionAnnotationKey">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_GqKshHiMEeOlpfB_tZS-QA" key="RegionZoneKey" value=""/>
+          </eAnnotations>
+          <children xmi:type="notation:DecorationNode" xmi:id="_GqKshXiMEeOlpfB_tZS-QA" type="3002">
+            <children xmi:type="notation:Shape" xmi:id="_IReBcHiMEeOlpfB_tZS-QA" type="8000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IReBcniMEeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IReBc3iMEeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IReBdHiMEeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IReBdXiMEeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IReBdniMEeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IReBd3iMEeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_IReBeHiMEeOlpfB_tZS-QA" type="8001">
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_IReBeXiMEeOlpfB_tZS-QA" x="-17" y="-32"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_IReBeniMEeOlpfB_tZS-QA" type="8002">
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_IReBe3iMEeOlpfB_tZS-QA" x="25" y="-10"/>
+              </children>
+              <element xmi:type="uml:Pseudostate" href="architecture-v3.uml#_IRX60HiMEeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IReBcXiMEeOlpfB_tZS-QA" x="41" y="223"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_IqdJMXiMEeOlpfB_tZS-QA" type="6000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IqdJM3iMEeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IqdJNHiMEeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IqdJNXiMEeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IqdJNniMEeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_IqdJN3iMEeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_IqdJOHiMEeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_IqdJOXiMEeOlpfB_tZS-QA" type="6001"/>
+              <children xmi:type="notation:DecorationNode" xmi:id="_IqdJOniMEeOlpfB_tZS-QA" visible="false" type="6002">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IqdJO3iMEeOlpfB_tZS-QA"/>
+              </children>
+              <element xmi:type="uml:State" href="architecture-v3.uml#_IqdJMHiMEeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_IqdJMniMEeOlpfB_tZS-QA" x="174" y="215"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_KcUvcXiMEeOlpfB_tZS-QA" type="6000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_KcUvc3iMEeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_KcUvdHiMEeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_KcUvdXiMEeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_KcUvdniMEeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_Kca2EHiMEeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_Kca2EXiMEeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_Kca2EniMEeOlpfB_tZS-QA" type="6001">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ObVisHiMEeOlpfB_tZS-QA" width="111"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_Kca2E3iMEeOlpfB_tZS-QA" visible="false" type="6002">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Kca2FHiMEeOlpfB_tZS-QA" y="-1" width="111"/>
+              </children>
+              <element xmi:type="uml:State" href="architecture-v3.uml#_KcUvcHiMEeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_KcUvcniMEeOlpfB_tZS-QA" x="442" y="122" width="111"/>
+            </children>
+            <children xmi:type="notation:Shape" xmi:id="_M9r48XiMEeOlpfB_tZS-QA" type="6000" fontName="Segoe UI" lineColor="0">
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_M9r483iMEeOlpfB_tZS-QA" source="ShadowFigure">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_M9r49HiMEeOlpfB_tZS-QA" key="ShadowFigure_Value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_M9r49XiMEeOlpfB_tZS-QA" source="displayNameLabelIcon">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_M9r49niMEeOlpfB_tZS-QA" key="displayNameLabelIcon_value" value="false"/>
+              </eAnnotations>
+              <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_M9r493iMEeOlpfB_tZS-QA" source="QualifiedName">
+                <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_M9r4-HiMEeOlpfB_tZS-QA" key="QualifiedNameDepth" value="1000"/>
+              </eAnnotations>
+              <children xmi:type="notation:DecorationNode" xmi:id="_M9r4-XiMEeOlpfB_tZS-QA" type="6001">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OG1SUHiMEeOlpfB_tZS-QA" width="109"/>
+              </children>
+              <children xmi:type="notation:DecorationNode" xmi:id="_M9x_kHiMEeOlpfB_tZS-QA" visible="false" type="6002">
+                <layoutConstraint xmi:type="notation:Bounds" xmi:id="_M9x_kXiMEeOlpfB_tZS-QA" y="-1" width="109"/>
+              </children>
+              <element xmi:type="uml:State" href="architecture-v3.uml#_M9r48HiMEeOlpfB_tZS-QA"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_M9r48niMEeOlpfB_tZS-QA" x="444" y="293" width="109"/>
+            </children>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GqKshniMEeOlpfB_tZS-QA"/>
+          </children>
+          <element xmi:type="uml:Region" href="architecture-v3.uml#_GqKscHiMEeOlpfB_tZS-QA"/>
+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GqKsh3iMEeOlpfB_tZS-QA" width="871" height="510"/>
+        </children>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GqKsiHiMEeOlpfB_tZS-QA" y="25" width="871" height="510"/>
+      </children>
+      <element xmi:type="uml:StateMachine" href="architecture-v3.uml#_E3DwEHiMEeOlpfB_tZS-QA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GqKsiXiMEeOlpfB_tZS-QA" x="30" y="30" width="871" height="535"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_GqKsiniMEeOlpfB_tZS-QA"/>
+    <element xmi:type="uml:StateMachine" href="architecture-v3.uml#_E3DwEHiMEeOlpfB_tZS-QA"/>
+    <edges xmi:type="notation:Connector" xmi:id="_Qsyn8HiMEeOlpfB_tZS-QA" type="7000" source="_IReBcHiMEeOlpfB_tZS-QA" target="_IqdJMXiMEeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Qsyn83iMEeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Qsyn9HiMEeOlpfB_tZS-QA" x="-3" y="26"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Qsyn9XiMEeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Qsyn9niMEeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Qsyn93iMEeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Qsyn-HiMEeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_Qsyn8XiMEeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_QsmasHiMEeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_Qsyn8niMEeOlpfB_tZS-QA" points="[10, -1, -133, -3]$[134, -18, -9, -20]"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_S2Hr8HiMEeOlpfB_tZS-QA" type="7000" source="_IqdJMXiMEeOlpfB_tZS-QA" target="_KcUvcXiMEeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_S2NykHiMEeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S2NykXiMEeOlpfB_tZS-QA" x="-18" y="-27"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S2NykniMEeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S2Nyk3iMEeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_S2NylHiMEeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_S2NylXiMEeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_S2Hr8XiMEeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_S2BlUHiMEeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_S2Hr8niMEeOlpfB_tZS-QA" points="[9, -4, -238, 80]$[237, -82, -10, 2]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_S2NylniMEeOlpfB_tZS-QA" id="(0.775,0.45)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_S2Nyl3iMEeOlpfB_tZS-QA" id="(0.12345679012345678,0.675)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_T6f6EHiMEeOlpfB_tZS-QA" type="7000" source="_IqdJMXiMEeOlpfB_tZS-QA" target="_M9r48XiMEeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_T6f6E3iMEeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_T6f6FHiMEeOlpfB_tZS-QA" x="-22" y="24"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_T6f6FXiMEeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_T6f6FniMEeOlpfB_tZS-QA" x="-16" y="15"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_T6mAsHiMEeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_T6mAsXiMEeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_T6f6EXiMEeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_T6ZzcHiMEeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_T6f6EniMEeOlpfB_tZS-QA" points="[9, 2, -236, -75]$[239, 77, -6, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_T6mAsniMEeOlpfB_tZS-QA" id="(0.775,0.55)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_T6mAs3iMEeOlpfB_tZS-QA" id="(0.0759493670886076,0.525)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_VI_GcHiMEeOlpfB_tZS-QA" type="7000" source="_M9r48XiMEeOlpfB_tZS-QA" target="_KcUvcXiMEeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_VI_Gc3iMEeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VI_GdHiMEeOlpfB_tZS-QA" x="-28" y="48"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VI_GdXiMEeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VI_GdniMEeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_VI_Gd3iMEeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_VI_GeHiMEeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_VI_GcXiMEeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_VI4_0HiMEeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_VI_GcniMEeOlpfB_tZS-QA" points="[1, -2, -68, 138]$[65, -133, -4, 7]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_VJLTsHiMEeOlpfB_tZS-QA" id="(0.7981651376146789,0.075)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_VJLTsXiMEeOlpfB_tZS-QA" id="(0.7207207207207207,0.825)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_WO4-kHiMEeOlpfB_tZS-QA" type="7000" source="_KcUvcXiMEeOlpfB_tZS-QA" target="_M9r48XiMEeOlpfB_tZS-QA" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_WO_FMHiMEeOlpfB_tZS-QA" type="7001">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WO_FMXiMEeOlpfB_tZS-QA" x="-21" y="11"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WO_FMniMEeOlpfB_tZS-QA" type="7002">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WO_FM3iMEeOlpfB_tZS-QA"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WO_FNHiMEeOlpfB_tZS-QA" type="7003">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WO_FNXiMEeOlpfB_tZS-QA" y="60"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_WO4-kXiMEeOlpfB_tZS-QA" fontName="Segoe UI"/>
+      <element xmi:type="uml:Transition" href="architecture-v3.uml#_WOy38HiMEeOlpfB_tZS-QA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_WO4-kniMEeOlpfB_tZS-QA" points="[2, 5, -71, -136]$[71, 136, -2, -5]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_WPFL0HiMEeOlpfB_tZS-QA" id="(0.0990990990990991,0.875)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_WPFL0XiMEeOlpfB_tZS-QA" id="(0.14678899082568808,0.25)"/>
+    </edges>
+  </notation:Diagram>
+  <notation:Diagram xmi:id="_qdZ18IeYEeOyqaF0O659SA" type="PapyrusUMLClassDiagram" name="Layer Factories" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_rnVScIeYEeOyqaF0O659SA" type="2004">
+      <children xmi:type="notation:DecorationNode" xmi:id="_rnVScoeYEeOyqaF0O659SA" type="5011"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rnVSc4eYEeOyqaF0O659SA" type="7006">
+        <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rnVSgoeYEeOyqaF0O659SA" source="PapyrusCSSForceValue">
+          <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rnVSg4eYEeOyqaF0O659SA" key="showTitle" value="true"/>
+        </eAnnotations>
+        <children xmi:type="notation:Shape" xmi:id="_Qvw9oIeZEeOyqaF0O659SA" type="3006">
+          <element xmi:type="uml:Property" href="architecture-v3.uml#_hG_gMoeYEeOyqaF0O659SA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Qvw9oYeZEeOyqaF0O659SA" x="183" y="9"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rnVSdIeYEeOyqaF0O659SA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rnVSdYeYEeOyqaF0O659SA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rnVSdoeYEeOyqaF0O659SA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rnVSd4eYEeOyqaF0O659SA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rnVSeIeYEeOyqaF0O659SA" type="7007">
+        <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rnVShIeYEeOyqaF0O659SA" source="PapyrusCSSForceValue">
+          <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rnVShYeYEeOyqaF0O659SA" key="showTitle" value="true"/>
+        </eAnnotations>
+        <children xmi:type="notation:Shape" xmi:id="_4LSiQIeYEeOyqaF0O659SA" type="3007">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__JmYMIeYEeOyqaF0O659SA" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_B0bmwIeZEeOyqaF0O659SA" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_hG_gNIeYEeOyqaF0O659SA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_4LSiQYeYEeOyqaF0O659SA" x="59" y="11"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_4mkwEIeYEeOyqaF0O659SA" type="3007">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__JylcoeYEeOyqaF0O659SA" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_B0n0AYeZEeOyqaF0O659SA" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_hHFm0oeYEeOyqaF0O659SA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_4mkwEYeYEeOyqaF0O659SA" x="115" y="29"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_5friUIeYEeOyqaF0O659SA" type="3007">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__JylcIeYEeOyqaF0O659SA" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_B0n0AIeZEeOyqaF0O659SA" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_hHFm2IeYEeOyqaF0O659SA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_5friUYeYEeOyqaF0O659SA" x="115" y="42"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_52YyIIeYEeOyqaF0O659SA" type="3007">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__Jse1oeYEeOyqaF0O659SA" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_B0htY4eZEeOyqaF0O659SA" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_hHFm3oeYEeOyqaF0O659SA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_52YyIYeYEeOyqaF0O659SA" x="132" y="53"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_6web0IeYEeOyqaF0O659SA" type="3007">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__Jse1IeYEeOyqaF0O659SA" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_B0htYoeZEeOyqaF0O659SA" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_hHFm5YeYEeOyqaF0O659SA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_6web0YeYEeOyqaF0O659SA" x="199" y="80"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_7JR9YIeYEeOyqaF0O659SA" type="3007">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__Jse0oeYEeOyqaF0O659SA" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_B0htYYeZEeOyqaF0O659SA" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_hHFm7IeYEeOyqaF0O659SA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_7JR9YYeYEeOyqaF0O659SA" x="160" y="108"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_7mePsIeYEeOyqaF0O659SA" type="3007">
+          <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="__Jse0IeYEeOyqaF0O659SA" source="CustomAppearance_Annotation">
+            <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_B0htYIeZEeOyqaF0O659SA" key="CustomAppearance_MaskValue" value="4872"/>
+          </eAnnotations>
+          <element xmi:type="uml:Operation" href="architecture-v3.uml#_hHFm94eYEeOyqaF0O659SA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_7mePsYeYEeOyqaF0O659SA" x="127" y="122"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rnVSeYeYEeOyqaF0O659SA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rnVSeoeYEeOyqaF0O659SA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rnVSe4eYEeOyqaF0O659SA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rnVSfIeYEeOyqaF0O659SA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_rnVSfYeYEeOyqaF0O659SA" type="7008">
+        <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_rnVShoeYEeOyqaF0O659SA" source="PapyrusCSSForceValue">
+          <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_rnVSh4eYEeOyqaF0O659SA" key="showTitle" value="true"/>
+        </eAnnotations>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_rnVSfoeYEeOyqaF0O659SA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_rnVSf4eYEeOyqaF0O659SA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_rnVSgIeYEeOyqaF0O659SA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rnVSgYeYEeOyqaF0O659SA"/>
+      </children>
+      <element xmi:type="uml:Interface" href="architecture-v3.uml#_hG_gMIeYEeOyqaF0O659SA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_rnVScYeYEeOyqaF0O659SA" x="178" y="47"/>
+    </children>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_qdZ18YeYEeOyqaF0O659SA"/>
+    <element xmi:type="uml:Model" href="architecture-v3.uml#_-7kCULZJEeK8zaQi-hvdlw"/>
+  </notation:Diagram>
+</xmi:XMI>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.uml b/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.uml
new file mode 100755
index 0000000..466a65f
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/models/architecture-v3.uml
@@ -0,0 +1,1244 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<uml:Model xmi:version="20110701" xmlns:xmi="http://www.omg.org/spec/XMI/20110701" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:uml="http://www.eclipse.org/uml2/4.0.0/UML" xmi:id="_-7kCULZJEeK8zaQi-hvdlw" name="model">
+  <packagedElement xmi:type="uml:Package" xmi:id="_IygSQLZKEeK8zaQi-hvdlw" clientDependency="_NCWW0LZKEeK8zaQi-hvdlw _Xjd4EL2QEeKKJJ5BmR3W3Q" name="runtime">
+    <packagedElement xmi:type="uml:Dependency" xmi:id="_NCWW0LZKEeK8zaQi-hvdlw" name="" client="_IygSQLZKEeK8zaQi-hvdlw" supplier="_KxbdELZKEeK8zaQi-hvdlw"/>
+    <packagedElement xmi:type="uml:Dependency" xmi:id="_Xjd4EL2QEeKKJJ5BmR3W3Q" name="Dependency1" client="_IygSQLZKEeK8zaQi-hvdlw" supplier="_ShE8QL2QEeKKJJ5BmR3W3Q"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_BY3WkNNnEeKwWoA8j13SIg" clientDependency="_g-43MNNpEeKwWoA8j13SIg" name="LayerStackService">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_Ue8PkNNnEeKwWoA8j13SIg" name="synchronizers" type="_LrbLgNNnEeKwWoA8j13SIg" aggregation="composite" association="_UfCWMNNnEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Ue8PkdNnEeKwWoA8j13SIg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Ue8PktNnEeKwWoA8j13SIg" value="*"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_p_kNgNNpEeKwWoA8j13SIg" name="layerStacks" type="_3qy5UNNnEeKwWoA8j13SIg" association="_p_wawNNpEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_p_kNgdNpEeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_p_kNgtNpEeKwWoA8j13SIg" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_9O7HwEyeEeObF6ELIGKT-g" name="layersSynchronizer" type="_T7VDsEyeEeObF6ELIGKT-g" aggregation="composite" association="_9O7u0EyeEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_9O7HwUyeEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_9O7HwkyeEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <interfaceRealization xmi:type="uml:InterfaceRealization" xmi:id="_g-43MNNpEeKwWoA8j13SIg" name="InterfaceRealization1" client="_BY3WkNNnEeKwWoA8j13SIg" supplier="_XlXjENNpEeKwWoA8j13SIg" contract="_XlXjENNpEeKwWoA8j13SIg"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_86bKcNNoEeKwWoA8j13SIg" name="getLayerStackSynchronizer"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_LrbLgNNnEeKwWoA8j13SIg" clientDependency="_f9KpkNNrEeKwWoA8j13SIg _gyvmsNNrEeKwWoA8j13SIg" name="LayerStackSynchronizer">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_z07zUNNtEeKwWoA8j13SIg">
+        <body>The Synchronizer is used to synchronize the properties of the Diagram when something change in the LayerStack.&#xD;
+The class listen to change events, then ask the LayerStack to compute the new values, and then set the new values in the diagram.</body>
+      </ownedComment>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_VXvf0NNnEeKwWoA8j13SIg" name="diagram" type="_rqknoM9UEeKO_rl5MA6s9A" association="_VX7tENNnEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_VXvf0dNnEeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_VXvf0tNnEeKwWoA8j13SIg" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_WYfyMNNnEeKwWoA8j13SIg" name="layerStack" type="_t0NNoM9UEeKO_rl5MA6s9A" association="_WYl40NNnEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_WYfyMdNnEeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_WYfyMtNnEeKwWoA8j13SIg" value="1"/>
+      </ownedAttribute>
+      <interfaceRealization xmi:type="uml:InterfaceRealization" xmi:id="_f9KpkNNrEeKwWoA8j13SIg" name="InterfaceRealization1" client="_LrbLgNNnEeKwWoA8j13SIg" supplier="_HJLoANNqEeKwWoA8j13SIg" contract="_HJLoANNqEeKwWoA8j13SIg"/>
+      <interfaceRealization xmi:type="uml:InterfaceRealization" xmi:id="_gyvmsNNrEeKwWoA8j13SIg" name="InterfaceRealization2" client="_LrbLgNNnEeKwWoA8j13SIg" supplier="_OS41oNNqEeKwWoA8j13SIg" contract="_OS41oNNqEeKwWoA8j13SIg"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_pEYFsNNrEeKwWoA8j13SIg" name="activate"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_qCessNNrEeKwWoA8j13SIg" name="deactivate"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_UfCWMNNnEeKwWoA8j13SIg" name="layerStackService_layerStackSynchronizer_1" memberEnd="_UfCWMdNnEeKwWoA8j13SIg _Ue8PkNNnEeKwWoA8j13SIg">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_UfCWMdNnEeKwWoA8j13SIg" name="layerStackService" type="_T7VDsEyeEeObF6ELIGKT-g" association="_UfCWMNNnEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_UfCWMtNnEeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_UfCWM9NnEeKwWoA8j13SIg" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_VX7tENNnEeKwWoA8j13SIg" name="layerStackSynchronizer_diagram_1" memberEnd="_VX7tEdNnEeKwWoA8j13SIg _VXvf0NNnEeKwWoA8j13SIg">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_VX7tEdNnEeKwWoA8j13SIg" name="layerStackSynchronizer" type="_LrbLgNNnEeKwWoA8j13SIg" association="_VX7tENNnEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_VX7tEtNnEeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_VX7tE9NnEeKwWoA8j13SIg" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_WYl40NNnEeKwWoA8j13SIg" name="layerStackSynchronizer_layerStack_1" memberEnd="_WYl40dNnEeKwWoA8j13SIg _WYfyMNNnEeKwWoA8j13SIg">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_WYl40dNnEeKwWoA8j13SIg" name="layerStackSynchronizer" type="_LrbLgNNnEeKwWoA8j13SIg" association="_WYl40NNnEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_WYl40tNnEeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_WYl409NnEeKwWoA8j13SIg" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_Tevr8NNpEeKwWoA8j13SIg" name="DiagramRemovedEventProvider"/>
+    <packagedElement xmi:type="uml:Interface" xmi:id="_XlXjENNpEeKwWoA8j13SIg" name="IDiagramRemovedEventProvider">
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_bdkjsNNpEeKwWoA8j13SIg" name="diagramRemovedEvent"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_p_wawNNpEeKwWoA8j13SIg" name="layerStackService_layerStacks_1" memberEnd="_p_wawdNpEeKwWoA8j13SIg _p_kNgNNpEeKwWoA8j13SIg">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_p_wawdNpEeKwWoA8j13SIg" name="layerStackService" type="_BY3WkNNnEeKwWoA8j13SIg" association="_p_wawNNpEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_p_wawtNpEeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_p_waw9NpEeKwWoA8j13SIg" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_z8UwcEydEeObF6ELIGKT-g" name="DerivedViewLayerSynchronizer">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_7ZAkcEydEeObF6ELIGKT-g">
+        <body>RegExpSynchronizer is responsible to synchronize all the RegExp of a LayersStack.</body>
+      </ownedComment>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_Yd4-AEygEeObF6ELIGKT-g" name="diagramEventListener" type="_HJLoANNqEeKwWoA8j13SIg" aggregation="composite" association="_YeA50EygEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Yd4-AUygEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Yd4-AkygEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_ZFFg4EygEeObF6ELIGKT-g" name="layersModelEventListener" type="_OS41oNNqEeKwWoA8j13SIg" aggregation="composite" association="_ZFGvAEygEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_ZFFg4UygEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_ZFFg4kygEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_UK_MIEylEeObF6ELIGKT-g" name="layerStack" type="_t0NNoM9UEeKO_rl5MA6s9A" association="_UK_MI0ylEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_UK_MIUylEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_UK_MIkylEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_S_ae8EynEeObF6ELIGKT-g" name="regExpLayerEventListener" type="_hYZzMEymEeObF6ELIGKT-g" aggregation="composite" association="_S_btEEynEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_S_ae8UynEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_S_ae8kynEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_m-hRsEynEeObF6ELIGKT-g" name="level1ViewChangedEventNotifier" type="_PHzwsEymEeObF6ELIGKT-g" aggregation="composite" association="_m-if0EynEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_m-hRsUynEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_m-hRskynEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_pSrFoEynEeObF6ELIGKT-g" name="anyViewChangedEventNotifier" type="_PHzwsEymEeObF6ELIGKT-g" aggregation="composite" association="_pSsTwEynEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_pSrFoUynEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_pSrFokynEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_0WZRwEynEeObF6ELIGKT-g" name="domainChangedEventNotifier" type="_NNG-kEymEeObF6ELIGKT-g" aggregation="composite" association="_0Waf4EynEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_0WZRwUynEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_0WZRwkynEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_x4a2oEyrEeObF6ELIGKT-g" name="domainPropertyChangedEventListener" type="_qwDXsEypEeObF6ELIGKT-g" aggregation="composite" association="_x4cEwEyrEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_x4a2oUyrEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_x4a2okyrEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_T7VDsEyeEeObF6ELIGKT-g" name="LayerStackApplicationSynchronizer">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_mrgIsEyfEeObF6ELIGKT-g" name="regExpSynchronizers" type="_z8UwcEydEeObF6ELIGKT-g" aggregation="composite" association="_mrhW0EyfEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_mrgIsUyfEeObF6ELIGKT-g"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_mrgIskyfEeObF6ELIGKT-g" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_9O7u0EyeEeObF6ELIGKT-g" name="layerStackService_layerStackApplicationSynchronizer_1" memberEnd="_9O7u0UyeEeObF6ELIGKT-g _9O7HwEyeEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_9O7u0UyeEeObF6ELIGKT-g" name="layerStackService" type="_BY3WkNNnEeKwWoA8j13SIg" association="_9O7u0EyeEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_9O7u0kyeEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_9O7u00yeEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_mrhW0EyfEeObF6ELIGKT-g" name="layerStackApplicationSynchronizer_regExpSynchronizer_1" memberEnd="_mrhW0UyfEeObF6ELIGKT-g _mrgIsEyfEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_mrhW0UyfEeObF6ELIGKT-g" name="layerStackApplicationSynchronizer" type="_T7VDsEyeEeObF6ELIGKT-g" association="_mrhW0EyfEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_mrhW0kyfEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_mrhW00yfEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_YeA50EygEeObF6ELIGKT-g" name="regExpSynchronizer_iDiagramEventListener_1" memberEnd="_YeA50UygEeObF6ELIGKT-g _Yd4-AEygEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_YeA50UygEeObF6ELIGKT-g" name="regExpSynchronizer" type="_PHzwsEymEeObF6ELIGKT-g" association="_YeA50EygEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_YeA50kygEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_YeA500ygEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_ZFGvAEygEeObF6ELIGKT-g" name="regExpSynchronizer_iLayersModelEventListener_1" memberEnd="_ZFGvAUygEeObF6ELIGKT-g _ZFFg4EygEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_ZFGvAUygEeObF6ELIGKT-g" name="regExpSynchronizer" type="_z8UwcEydEeObF6ELIGKT-g" association="_ZFGvAEygEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_ZFGvAkygEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_ZFGvA0ygEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_-mWi0EygEeObF6ELIGKT-g" clientDependency="_Z_oBEEyhEeObF6ELIGKT-g" name="LayersStackAndApplicationLifeCycleEventNotifier"/>
+    <packagedElement xmi:type="uml:Interface" xmi:id="_GmQYoEyhEeObF6ELIGKT-g" name="ILayersStackApplicationEventListener">
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_L2KMAEyhEeObF6ELIGKT-g" name="layerStackAdded"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_M_w4YEyhEeObF6ELIGKT-g" name="layerStackRemoved"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_VVf0QEyhEeObF6ELIGKT-g" clientDependency="_bc3bIEyhEeObF6ELIGKT-g" name="LayersStackApplicationEventNotifier"/>
+    <packagedElement xmi:type="uml:Usage" xmi:id="_Z_oBEEyhEeObF6ELIGKT-g" name="Usage1" client="_-mWi0EygEeObF6ELIGKT-g" supplier="_GmQYoEyhEeObF6ELIGKT-g"/>
+    <packagedElement xmi:type="uml:Usage" xmi:id="_bc3bIEyhEeObF6ELIGKT-g" name="Usage2" client="_VVf0QEyhEeObF6ELIGKT-g" supplier="_GmQYoEyhEeObF6ELIGKT-g"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_loxOcEyhEeObF6ELIGKT-g" clientDependency="_uaimEEyhEeObF6ELIGKT-g" name="NotationDiagramRemovedFromResourceEventNotifier"/>
+    <packagedElement xmi:type="uml:Interface" xmi:id="_qDr6kEyhEeObF6ELIGKT-g" name="INotationDiagramRemovedEventListener">
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_s_IYAEyhEeObF6ELIGKT-g" name="diagramRemoved"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Usage" xmi:id="_uaimEEyhEeObF6ELIGKT-g" name="Usage3" client="_loxOcEyhEeObF6ELIGKT-g" supplier="_qDr6kEyhEeObF6ELIGKT-g"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_a8pioEykEeObF6ELIGKT-g" clientDependency="_cXr9QEykEeObF6ELIGKT-g" name="LayersModelEventNotifier"/>
+    <packagedElement xmi:type="uml:Usage" xmi:id="_cXr9QEykEeObF6ELIGKT-g" name="Usage4" client="_a8pioEykEeObF6ELIGKT-g" supplier="_OS41oNNqEeKwWoA8j13SIg"/>
+    <packagedElement xmi:type="uml:Association" xmi:id="_UK_MI0ylEeObF6ELIGKT-g" name="regExpSynchronizer_layerStack_1" memberEnd="_UK_MJEylEeObF6ELIGKT-g _UK_MIEylEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_UK_MJEylEeObF6ELIGKT-g" name="regExpSynchronizer" type="_z8UwcEydEeObF6ELIGKT-g" association="_UK_MI0ylEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_UK_MJUylEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_UK_MJkylEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_iIr2EEylEeObF6ELIGKT-g" name="EventNotifier">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_wC9YkEylEeObF6ELIGKT-g">
+        <body>This class is used to record a list of listeners, and to send the associated event when the fireMethod is called</body>
+      </ownedComment>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_9fD74EymEeObF6ELIGKT-g" name="listeners" type="_u6-HIM-xEeKO_rl5MA6s9A" association="_9fFKAEymEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_9fD74UymEeObF6ELIGKT-g"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_9fD74kymEeObF6ELIGKT-g" value="*"/>
+      </ownedAttribute>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_32mUAEylEeObF6ELIGKT-g" name="attachListener"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_52Ii0EylEeObF6ELIGKT-g" name="removeListener"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_71ZE0EylEeObF6ELIGKT-g" name="fireEvent"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_NNG-kEymEeObF6ELIGKT-g" name="DomainChangedEventManager">
+      <generalization xmi:type="uml:Generalization" xmi:id="_JsQRgEynEeObF6ELIGKT-g" general="_iIr2EEylEeObF6ELIGKT-g"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_itq40EytEeObF6ELIGKT-g" name="domainPropertyChangedEventNotifier" type="_rezFUEyvEeObF6ELIGKT-g" association="_itrf4EytEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_itq40UytEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_itq40kytEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_KiB0MEytEeObF6ELIGKT-g" name="startListening"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_MECZgEytEeObF6ELIGKT-g" name="stopListening"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_PHzwsEymEeObF6ELIGKT-g" name="ViewListChangedEventManager">
+      <generalization xmi:type="uml:Generalization" xmi:id="_KWW-cEynEeObF6ELIGKT-g" general="_iIr2EEylEeObF6ELIGKT-g"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_I--QkEyuEeObF6ELIGKT-g" name="diagramViewEventNotifier" type="_JwRLoEyjEeObF6ELIGKT-g" association="_I--3oEyuEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_I--QkUyuEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_I--QkkyuEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_xe-J8EytEeObF6ELIGKT-g" name="startListening"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_xe-J8UytEeObF6ELIGKT-g" name="stopListening"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Interface" xmi:id="_hYZzMEymEeObF6ELIGKT-g" name="IRegExpLayerEventListener">
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_psYbkEymEeObF6ELIGKT-g" name="selectedEventTypesChanged"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_vtheoEymEeObF6ELIGKT-g" name="expressionChanged"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_9fFKAEymEeObF6ELIGKT-g" name="eventNotifier_regExpLayer_1" memberEnd="_9fFKAUymEeObF6ELIGKT-g _9fD74EymEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_9fFKAUymEeObF6ELIGKT-g" name="eventNotifier" type="_iIr2EEylEeObF6ELIGKT-g" association="_9fFKAEymEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_9fFKAkymEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_9fFKA0ymEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_S_btEEynEeObF6ELIGKT-g" name="regExpSynchronizer_iRegExpLayerEventListener_1" memberEnd="_S_btEUynEeObF6ELIGKT-g _S_ae8EynEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_S_btEUynEeObF6ELIGKT-g" name="regExpSynchronizer" type="_z8UwcEydEeObF6ELIGKT-g" association="_S_btEEynEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_S_btEkynEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_S_btE0ynEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_m-if0EynEeObF6ELIGKT-g" name="regExpSynchronizer_viewListChangedEventNotifier_1" memberEnd="_m-if0UynEeObF6ELIGKT-g _m-hRsEynEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_m-if0UynEeObF6ELIGKT-g" name="regExpSynchronizer" type="_z8UwcEydEeObF6ELIGKT-g" association="_m-if0EynEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_m-if0kynEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_m-if00ynEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_pSsTwEynEeObF6ELIGKT-g" name="regExpSynchronizer_viewListChangedEventNotifier_2" memberEnd="_pSsTwUynEeObF6ELIGKT-g _pSrFoEynEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_pSsTwUynEeObF6ELIGKT-g" name="regExpSynchronizer" type="_z8UwcEydEeObF6ELIGKT-g" association="_pSsTwEynEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_pSsTwkynEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_pSsTw0ynEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_0Waf4EynEeObF6ELIGKT-g" name="regExpSynchronizer_domainChangedEventNotifier_1" memberEnd="_0Waf4UynEeObF6ELIGKT-g _0WZRwEynEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_0Waf4UynEeObF6ELIGKT-g" name="regExpSynchronizer" type="_z8UwcEydEeObF6ELIGKT-g" association="_0Waf4EynEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_0Waf4kynEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_0Waf40ynEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_l9oKgEypEeObF6ELIGKT-g" clientDependency="_uEDfEEypEeObF6ELIGKT-g" name="DomainPropertyChangedEventNotifier">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_Bigb0EyqEeObF6ELIGKT-g" annotatedElement="_l9oKgEypEeObF6ELIGKT-g">
+        <body>This notifier allows to listen on property changes on any children of the specified object.</body>
+      </ownedComment>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_WxdF0EyqEeObF6ELIGKT-g" name="attachListener"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_YO_a0EyqEeObF6ELIGKT-g" name="removeListener"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_Z096IEyqEeObF6ELIGKT-g" name="addObservedObject">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_s2Rn4EyqEeObF6ELIGKT-g" name="obj" type="_3MwTgEyqEeObF6ELIGKT-g"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_bz66IEyqEeObF6ELIGKT-g" name="removeObservedObject"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_oHUooEyuEeObF6ELIGKT-g" name="stopListening"/>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_oHVPsEyuEeObF6ELIGKT-g" name="startListening"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Interface" xmi:id="_qwDXsEypEeObF6ELIGKT-g" name="IDomainPropertyChangedEventListener"/>
+    <packagedElement xmi:type="uml:Usage" xmi:id="_uEDfEEypEeObF6ELIGKT-g" name="Usage5" client="_l9oKgEypEeObF6ELIGKT-g" supplier="_qwDXsEypEeObF6ELIGKT-g"/>
+    <packagedElement xmi:type="uml:Association" xmi:id="_x4cEwEyrEeObF6ELIGKT-g" name="regExpSynchronizer_iDomainPropertyChangedEventNotiffier_1" memberEnd="_x4cEwUyrEeObF6ELIGKT-g _x4a2oEyrEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_x4cEwUyrEeObF6ELIGKT-g" name="regExpSynchronizer" type="_NNG-kEymEeObF6ELIGKT-g" association="_x4cEwEyrEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_x4cEwkyrEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_x4cEw0yrEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_itrf4EytEeObF6ELIGKT-g" name="domainChangedEventManager_domainPropertyChangedEventNotifier_1" memberEnd="_itrf4UytEeObF6ELIGKT-g _itq40EytEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_itrf4UytEeObF6ELIGKT-g" name="domainChangedEventManager" type="_NNG-kEymEeObF6ELIGKT-g" association="_itrf4EytEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_itrf4kytEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_itrf40ytEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_I--3oEyuEeObF6ELIGKT-g" name="viewListChangedEventManager_diagramViewEventNotifier_1" memberEnd="_I--3oUyuEeObF6ELIGKT-g _I--QkEyuEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_I--3oUyuEeObF6ELIGKT-g" name="viewListChangedEventManager" type="_PHzwsEymEeObF6ELIGKT-g" association="_I--3oEyuEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_I--3okyuEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_I--3o0yuEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_rezFUEyvEeObF6ELIGKT-g" clientDependency="_NrCFIEywEeObF6ELIGKT-g" name="DiagramDomainPropertyChangedEventNotifier">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_8Z6ioEyvEeObF6ELIGKT-g" annotatedElement="_rezFUEyvEeObF6ELIGKT-g">
+        <body>Fire events when a property of one of the domain element of the diagram is modified.&#xD;
+This notifier tracks the diagram root elements, and listen to their asociated domain elements.&#xD;
+</body>
+      </ownedComment>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_WYVzgEywEeObF6ELIGKT-g" name="domainPropertyChangedEventNotifier" type="_l9oKgEypEeObF6ELIGKT-g" aggregation="composite" association="_WYWakEywEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_WYVzgUywEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_WYVzgkywEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_gjmGkEywEeObF6ELIGKT-g" name="diagramViewEventNotifier" type="_JwRLoEyjEeObF6ELIGKT-g" association="_gjmtoEywEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_gjmGkUywEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_gjmGkkywEeObF6ELIGKT-g" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Usage" xmi:id="_NrCFIEywEeObF6ELIGKT-g" name="Usage6" client="_rezFUEyvEeObF6ELIGKT-g" supplier="_qwDXsEypEeObF6ELIGKT-g"/>
+    <packagedElement xmi:type="uml:Association" xmi:id="_WYWakEywEeObF6ELIGKT-g" name="diagramDomainPropertyChangedEventNotifier_domainPropertyChangedEventNotifier_1" memberEnd="_WYWakUywEeObF6ELIGKT-g _WYVzgEywEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_WYWakUywEeObF6ELIGKT-g" name="diagramDomainPropertyChangedEventNotifier" type="_rezFUEyvEeObF6ELIGKT-g" association="_WYWakEywEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_WYWakkywEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_WYWak0ywEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_gjmtoEywEeObF6ELIGKT-g" name="diagramDomainPropertyChangedEventNotifier_diagramViewEventNotifier_1" memberEnd="_gjmtoUywEeObF6ELIGKT-g _gjmGkEywEeObF6ELIGKT-g">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_gjmtoUywEeObF6ELIGKT-g" name="diagramDomainPropertyChangedEventNotifier" type="_rezFUEyvEeObF6ELIGKT-g" association="_gjmtoEywEeObF6ELIGKT-g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_gjmtokywEeObF6ELIGKT-g" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_gjmto0ywEeObF6ELIGKT-g" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Model" xmi:id="_bAQtoFzGEeOeP67GJGKDkA" name="regexp">
+      <packagedElement xmi:type="uml:Class" xmi:id="_sc15QFzGEeOeP67GJGKDkA" clientDependency="_vWp3oFzJEeOeP67GJGKDkA" name="ExpressionMatcher">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_lp2GAFzHEeOeP67GJGKDkA" annotatedElement="_sc15QFzGEeOeP67GJGKDkA">
+          <body>This class evaluate its associated expression against the associated models.&#xD;
+It provide a list of elements matching the expression in the model.&#xD;
+It fire some events when the list of matching elements change.&#xD;
+The expression is evaluated  each time a change impacting the result occurs in the model.&#xD;
+&#xD;
+It maybe necessary to adjust the listeners on model changes to improve performances.</body>
+        </ownedComment>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_GIXm0FzIEeOeP67GJGKDkA" name="expr" visibility="public" type="_70TEoNIPEeKovM8ingMMQQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Hwmv8FzIEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Hwmv8VzIEeOeP67GJGKDkA" value="1"/>
+          <defaultValue xmi:type="uml:LiteralString" xmi:id="_Hwmv8lzIEeOeP67GJGKDkA">
+            <value xsi:nil="true"/>
+          </defaultValue>
+        </ownedAttribute>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_ISLL8FzIEeOeP67GJGKDkA" name="model" visibility="public" type="_t0NNoM9UEeKO_rl5MA6s9A">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_RvpL8FzIEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_RvpL8VzIEeOeP67GJGKDkA" value="1"/>
+          <defaultValue xmi:type="uml:LiteralString" xmi:id="_RvpL8lzIEeOeP67GJGKDkA">
+            <value xsi:nil="true"/>
+          </defaultValue>
+        </ownedAttribute>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_oFbiMFzIEeOeP67GJGKDkA" name="modelChangedListeners" visibility="public">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_qariUFzIEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_qariUVzIEeOeP67GJGKDkA" value="1"/>
+          <defaultValue xmi:type="uml:LiteralString" xmi:id="_qariUlzIEeOeP67GJGKDkA">
+            <value xsi:nil="true"/>
+          </defaultValue>
+        </ownedAttribute>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_dTKyIFzLEeOeP67GJGKDkA" name="expressionMatchElementsChangedListeners" type="_rYYgsFzIEeOeP67GJGKDkA" association="_dTQ4wFzLEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_dTKyIVzLEeOeP67GJGKDkA"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_dTKyIlzLEeOeP67GJGKDkA" value="*"/>
+        </ownedAttribute>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_IDVscFzNEeOeP67GJGKDkA" name="matchingElements" type="_j52EYNIUEeKovM8ingMMQQ" association="_IDVsc1zNEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_IDVscVzNEeOeP67GJGKDkA"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_IDVsclzNEeOeP67GJGKDkA" value="*"/>
+        </ownedAttribute>
+        <interfaceRealization xmi:type="uml:InterfaceRealization" xmi:id="_vWp3oFzJEeOeP67GJGKDkA" name="InterfaceRealization1" client="_sc15QFzGEeOeP67GJGKDkA" supplier="_hd8bYFzJEeOeP67GJGKDkA" contract="_hd8bYFzJEeOeP67GJGKDkA"/>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_dUYacFzIEeOeP67GJGKDkA" name="addMatchingElementsChangedListener"/>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_f2gY8FzIEeOeP67GJGKDkA" name="removematchingElementsChangedListener"/>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_kFdssFzIEeOeP67GJGKDkA" name="fireMatchingElementChanged"/>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_rYYgsFzIEeOeP67GJGKDkA" clientDependency="_bBitwFzLEeOeP67GJGKDkA" name="ExpressionMatchElementsChangedListener">
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_rjEmYFzLEeOeP67GJGKDkA" name="expresionResultChanged"/>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Interface" xmi:id="_4ZF98FzIEeOeP67GJGKDkA" clientDependency="_Yg2SoFzLEeOeP67GJGKDkA _ZvbloFzLEeOeP67GJGKDkA" name="IModelChangedNotifier">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_O9YDMFzJEeOeP67GJGKDkA" annotatedElement="_4ZF98FzIEeOeP67GJGKDkA">
+          <body>Interface to be implemented by class notifying changes in a model.&#xD;
+This interface is used by ExpressionMatcher to listen on various part of model changes.</body>
+        </ownedComment>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="__cB1MFzIEeOeP67GJGKDkA" name="addModelChangedListener">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_46F8wFzJEeOeP67GJGKDkA" name="listener" type="_hd8bYFzJEeOeP67GJGKDkA"/>
+        </ownedOperation>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_fsE1IFzJEeOeP67GJGKDkA" name="removeModelChangedListener">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_8TL_gFzJEeOeP67GJGKDkA" name="listener" type="_hd8bYFzJEeOeP67GJGKDkA"/>
+        </ownedOperation>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Interface" xmi:id="_hd8bYFzJEeOeP67GJGKDkA" name="IModelChangedListener">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_oer6QFzJEeOeP67GJGKDkA" annotatedElement="_hd8bYFzJEeOeP67GJGKDkA">
+          <body>Interface implemented by listener whishing to listen on a IModelChangedNotifier.</body>
+        </ownedComment>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_-Vl8IFzJEeOeP67GJGKDkA" name="modelchanged">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_KmJHwFzKEeOeP67GJGKDkA" name="event" type="_Aii74FzKEeOeP67GJGKDkA"/>
+        </ownedOperation>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_Aii74FzKEeOeP67GJGKDkA" name="ModelChangedEvent"/>
+      <packagedElement xmi:type="uml:Class" xmi:id="_SOF7IFzLEeOeP67GJGKDkA" name="ExpressionMatcherElementsChangedEvent">
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_yKWcYFzLEeOeP67GJGKDkA" name="expressionMatcher" type="_sc15QFzGEeOeP67GJGKDkA" association="_yKWcY1zLEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_yKWcYVzLEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_yKWcYlzLEeOeP67GJGKDkA" value="1"/>
+        </ownedAttribute>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_oS7O0FzMEeOeP67GJGKDkA" name="removedElements" type="_j52EYNIUEeKovM8ingMMQQ" association="_oS7O01zMEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_oS7O0VzMEeOeP67GJGKDkA"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_oS7O0lzMEeOeP67GJGKDkA" value="*"/>
+        </ownedAttribute>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_o7viUFzMEeOeP67GJGKDkA" name="addedElements" type="_j52EYNIUEeKovM8ingMMQQ" association="_o7viU1zMEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_o7viUVzMEeOeP67GJGKDkA"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_o7viUlzMEeOeP67GJGKDkA" value="*"/>
+        </ownedAttribute>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Usage" xmi:id="_Yg2SoFzLEeOeP67GJGKDkA" name="Usage1" client="_4ZF98FzIEeOeP67GJGKDkA" supplier="_hd8bYFzJEeOeP67GJGKDkA"/>
+      <packagedElement xmi:type="uml:Usage" xmi:id="_ZvbloFzLEeOeP67GJGKDkA" name="Usage2" client="_4ZF98FzIEeOeP67GJGKDkA" supplier="_Aii74FzKEeOeP67GJGKDkA"/>
+      <packagedElement xmi:type="uml:Usage" xmi:id="_bBitwFzLEeOeP67GJGKDkA" name="Usage3" client="_rYYgsFzIEeOeP67GJGKDkA" supplier="_SOF7IFzLEeOeP67GJGKDkA"/>
+      <packagedElement xmi:type="uml:Association" xmi:id="_dTQ4wFzLEeOeP67GJGKDkA" name="expressionMatcher_expressionMatchElementsChangedListener_1" memberEnd="_dTQ4wVzLEeOeP67GJGKDkA _dTKyIFzLEeOeP67GJGKDkA">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_dTQ4wVzLEeOeP67GJGKDkA" name="expressionMatcher" type="_sc15QFzGEeOeP67GJGKDkA" association="_dTQ4wFzLEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_dTQ4wlzLEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_dTQ4w1zLEeOeP67GJGKDkA" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_yKWcY1zLEeOeP67GJGKDkA" name="expressionMatcherElementsChangedEvent_expressionMatcher_1" memberEnd="_yKWcZFzLEeOeP67GJGKDkA _yKWcYFzLEeOeP67GJGKDkA">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_yKWcZFzLEeOeP67GJGKDkA" name="expressionMatcherElementsChangedEvent" type="_SOF7IFzLEeOeP67GJGKDkA" association="_yKWcY1zLEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_yKWcZVzLEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_yKWcZlzLEeOeP67GJGKDkA" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_oS7O01zMEeOeP67GJGKDkA" name="expressionMatcherElementsChangedEvent_view_1" memberEnd="_oS7O1FzMEeOeP67GJGKDkA _oS7O0FzMEeOeP67GJGKDkA">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_oS7O1FzMEeOeP67GJGKDkA" name="expressionMatcherElementsChangedEvent" type="_SOF7IFzLEeOeP67GJGKDkA" association="_oS7O01zMEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_oS7O1VzMEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_oS7O1lzMEeOeP67GJGKDkA" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_o7viU1zMEeOeP67GJGKDkA" name="expressionMatcherElementsChangedEvent_view_2" memberEnd="_o7viVFzMEeOeP67GJGKDkA _o7viUFzMEeOeP67GJGKDkA">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_o7viVFzMEeOeP67GJGKDkA" name="expressionMatcherElementsChangedEvent" type="_SOF7IFzLEeOeP67GJGKDkA" association="_o7viU1zMEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_o7viVVzMEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_o7viVlzMEeOeP67GJGKDkA" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_IDVsc1zNEeOeP67GJGKDkA" clientDependency="_PlHmYFzOEeOeP67GJGKDkA" name="expressionMatcher_view_1" memberEnd="_IDVsdFzNEeOeP67GJGKDkA _IDVscFzNEeOeP67GJGKDkA">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_IDVsdFzNEeOeP67GJGKDkA" name="expressionMatcher" type="_sc15QFzGEeOeP67GJGKDkA" association="_IDVsc1zNEeOeP67GJGKDkA">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_IDVsdVzNEeOeP67GJGKDkA" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_IDVsdlzNEeOeP67GJGKDkA" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_G65oQFzOEeOeP67GJGKDkA" name="NotifyingList"/>
+      <packagedElement xmi:type="uml:Usage" xmi:id="_PlHmYFzOEeOeP67GJGKDkA" name="Usage4" client="_IDVsc1zNEeOeP67GJGKDkA" supplier="_G65oQFzOEeOeP67GJGKDkA"/>
+      <packagedElement xmi:type="uml:Class" xmi:id="_IwYtwFzPEeOeP67GJGKDkA" name="NotationChangedNotifier">
+        <generalization xmi:type="uml:Generalization" xmi:id="_Y_TMYFzPEeOeP67GJGKDkA" general="_SNeTQFzPEeOeP67GJGKDkA"/>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_PA30YFzPEeOeP67GJGKDkA" clientDependency="_R09soFzPEeOeP67GJGKDkA" name="UMLChangedNotifier">
+        <generalization xmi:type="uml:Generalization" xmi:id="_ZwmtgFzPEeOeP67GJGKDkA" general="_SNeTQFzPEeOeP67GJGKDkA"/>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_SNeTQFzPEeOeP67GJGKDkA" clientDependency="_R09soFzPEeOeP67GJGKDkA" name="AbstractModelChangedNotifier">
+        <interfaceRealization xmi:type="uml:InterfaceRealization" xmi:id="_R09soFzPEeOeP67GJGKDkA" name="InterfaceRealization1" client="_PA30YFzPEeOeP67GJGKDkA _SNeTQFzPEeOeP67GJGKDkA" supplier="_4ZF98FzIEeOeP67GJGKDkA" contract="_4ZF98FzIEeOeP67GJGKDkA"/>
+      </packagedElement>
+    </packagedElement>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Package" xmi:id="_KAehQLZKEeK8zaQi-hvdlw" clientDependency="_OVNs4LZKEeK8zaQi-hvdlw" name="ui">
+    <ownedComment xmi:type="uml:Comment" xmi:id="_1S4tEM9REeKO_rl5MA6s9A">
+      <body> </body>
+    </ownedComment>
+    <packagedElement xmi:type="uml:Dependency" xmi:id="_OVNs4LZKEeK8zaQi-hvdlw" name="Dependency1" client="_KAehQLZKEeK8zaQi-hvdlw" supplier="_IygSQLZKEeK8zaQi-hvdlw"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_hwJtQM9REeKO_rl5MA6s9A" name="LayersViewer">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_LgxZoM9UEeKO_rl5MA6s9A" name="selectionView" type="_yeyNwM9REeKO_rl5MA6s9A" aggregation="composite" association="_Lg4HUM9UEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_LgxZoc9UEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_LgxZos9UEeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_jfm4sM9REeKO_rl5MA6s9A" name="LayerStackUiPart">
+      <generalization xmi:type="uml:Generalization" xmi:id="_TdEXQM9TEeKO_rl5MA6s9A" general="_G-A1kM9TEeKO_rl5MA6s9A"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_45dq0M9UEeKO_rl5MA6s9A" name="diagram" type="_rqknoM9UEeKO_rl5MA6s9A" association="_45kYgM9UEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_45dq0c9UEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_45dq0s9UEeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_5vJVoM9UEeKO_rl5MA6s9A" name="layerStack" type="_t0NNoM9UEeKO_rl5MA6s9A" association="_5vWJ8M9UEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_5vJVoc9UEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_5vJVos9UEeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_l8z68M9REeKO_rl5MA6s9A" name="DiagramUiPart">
+      <generalization xmi:type="uml:Generalization" xmi:id="_S5l2wM9TEeKO_rl5MA6s9A" general="_G-A1kM9TEeKO_rl5MA6s9A"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_w0UIoM9UEeKO_rl5MA6s9A" name="diagram" type="_rqknoM9UEeKO_rl5MA6s9A" association="_w0iyIM9UEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_w0UIoc9UEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_w0UIos9UEeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_nrEMgM9REeKO_rl5MA6s9A" name="UnknownSelectionUiPart">
+      <generalization xmi:type="uml:Generalization" xmi:id="_SaqfEM9TEeKO_rl5MA6s9A" general="_G-A1kM9TEeKO_rl5MA6s9A"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_yeyNwM9REeKO_rl5MA6s9A" clientDependency="_Ecf7EM9TEeKO_rl5MA6s9A" name="SelectionView">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_-YSyYM9REeKO_rl5MA6s9A">
+        <body>This view show the current selection among:&#xD;
+- Diagram with LayerStack&#xD;
+- Diagram without LayerStack&#xD;
+- other selection (unknown)&#xD;
+</body>
+      </ownedComment>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="__C2gYM9TEeKO_rl5MA6s9A" name="uiPart" type="_G-A1kM9TEeKO_rl5MA6s9A" aggregation="composite" association="__DARYM9TEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="__C2gYc9TEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="__C2gYs9TEeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_cw2FMM9SEeKO_rl5MA6s9A" name="SelectionTracker">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_hEcoYM9SEeKO_rl5MA6s9A">
+        <body>This class track the current selection and fire following events:&#xD;
+- diagramWithoutStackLayerSelected (editor, diagram)&#xD;
+- diagramWithStackLayerSelected (editor, diagram, StackLayer)&#xD;
+- unknown selection (editor(could be null) )</body>
+      </ownedComment>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Dependency" xmi:id="_Ecf7EM9TEeKO_rl5MA6s9A" name="" client="_yeyNwM9REeKO_rl5MA6s9A" supplier="_cw2FMM9SEeKO_rl5MA6s9A"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_G-A1kM9TEeKO_rl5MA6s9A" name="UiPart" isAbstract="true">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_rcDK0M9REeKO_rl5MA6s9A">
+        <body>A UiPart is used to show one element (and its subelements&#xD;
+</body>
+      </ownedComment>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="__DARYM9TEeKO_rl5MA6s9A" name="selectionView_uiPart_1" memberEnd="__DARYc9TEeKO_rl5MA6s9A __C2gYM9TEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="__DARYc9TEeKO_rl5MA6s9A" name="selectionView" type="_yeyNwM9REeKO_rl5MA6s9A" association="__DARYM9TEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="__DARYs9TEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="__DARY89TEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_Lg4HUM9UEeKO_rl5MA6s9A" name="layersViewer_selectionView_1" memberEnd="_Lg4HUc9UEeKO_rl5MA6s9A _LgxZoM9UEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_Lg4HUc9UEeKO_rl5MA6s9A" name="layersViewer" type="_hwJtQM9REeKO_rl5MA6s9A" association="_Lg4HUM9UEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Lg4HUs9UEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Lg4HU89UEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_w0iyIM9UEeKO_rl5MA6s9A" name="diagramUiPart_diagram_1" memberEnd="_w0iyIc9UEeKO_rl5MA6s9A _w0UIoM9UEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_w0iyIc9UEeKO_rl5MA6s9A" name="diagramUiPart" type="_l8z68M9REeKO_rl5MA6s9A" association="_w0iyIM9UEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_w0iyIs9UEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_w0iyI89UEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_45kYgM9UEeKO_rl5MA6s9A" name="layerStackUiPart_diagram_1" memberEnd="_45kYgc9UEeKO_rl5MA6s9A _45dq0M9UEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_45kYgc9UEeKO_rl5MA6s9A" name="layerStackUiPart" type="_jfm4sM9REeKO_rl5MA6s9A" association="_45kYgM9UEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_45kYgs9UEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_45kYg89UEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_5vWJ8M9UEeKO_rl5MA6s9A" name="layerStackUiPart_layerStack_1" memberEnd="_5vWJ8c9UEeKO_rl5MA6s9A _5vJVoM9UEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_5vWJ8c9UEeKO_rl5MA6s9A" name="layerStackUiPart" type="_jfm4sM9REeKO_rl5MA6s9A" association="_5vWJ8M9UEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_5vWJ8s9UEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_5vWJ889UEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Package" xmi:id="_KxbdELZKEeK8zaQi-hvdlw" clientDependency="_V114oL2QEeKKJJ5BmR3W3Q" name="stackmodel">
+    <ownedComment xmi:type="uml:Comment" xmi:id="_k5v3oNITEeKovM8ingMMQQ">
+      <body>A LayerExpression allows to compute the properties of a specified view.&#xD;
+A LayerExpression is the common ancestor of Layer and LayerOperator.</body>
+    </ownedComment>
+    <packagedElement xmi:type="uml:Dependency" xmi:id="_V114oL2QEeKKJJ5BmR3W3Q" name="Dependency1" client="_KxbdELZKEeK8zaQi-hvdlw" supplier="_ShE8QL2QEeKKJJ5BmR3W3Q"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_t0NNoM9UEeKO_rl5MA6s9A" name="LayerStack">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_3hmqkM9VEeKO_rl5MA6s9A" name="diagram" type="_rqknoM9UEeKO_rl5MA6s9A" association="_3h0tAM9VEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_3hmqkc9VEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_3hmqks9VEeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_4B6F4NN0EeKwWoA8j13SIg" name="selectionManager" type="_iOVr4NN0EeKwWoA8j13SIg" association="_4CAMgNN0EeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_4B6F4dN0EeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_4B6F4tN0EeKwWoA8j13SIg" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_3h0tAM9VEeKO_rl5MA6s9A" name="layerStack_diagram_1" memberEnd="_3h0tAc9VEeKO_rl5MA6s9A _3hmqkM9VEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_3h0tAc9VEeKO_rl5MA6s9A" name="layerStack" type="_t0NNoM9UEeKO_rl5MA6s9A" association="_3h0tAM9VEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_3h0tAs9VEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_3h0tA89VEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_55Ll8M9VEeKO_rl5MA6s9A" name="namedStyle_layerStack_1" memberEnd="_55Ll8c9VEeKO_rl5MA6s9A _54-KkM9VEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_55Ll8c9VEeKO_rl5MA6s9A" name="namedStyle" type="_0Q5HwM9VEeKO_rl5MA6s9A" association="_55Ll8M9VEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_55Ll8s9VEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_55Ll889VEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_q3GegM-wEeKO_rl5MA6s9A" name="LayerExpression" isAbstract="true">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_unLCYNIXEeKovM8ingMMQQ" name="attachedViews" type="_kextsM-0EeKO_rl5MA6s9A" isDerived="true" association="_unRJANIXEeKovM8ingMMQQ">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_6FrGANIXEeKovM8ingMMQQ">
+          <body>List of views attached to the layerExpression. This is a derived properties.</body>
+        </ownedComment>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_unLCYdIXEeKovM8ingMMQQ"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_unLCYtIXEeKovM8ingMMQQ" value="*"/>
+      </ownedAttribute>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="__kusgNITEeKovM8ingMMQQ" name="getViewProperties">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_Sz7FQNIUEeKovM8ingMMQQ">
+          <body>Get the property descriptors associated to the specified view.</body>
+        </ownedComment>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_geO5INIUEeKovM8ingMMQQ" name="view" type="_j52EYNIUEeKovM8ingMMQQ"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_vg2jwNIUEeKovM8ingMMQQ" name="result" type="_UzekYM-yEeKO_rl5MA6s9A" direction="return">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_0CFTQNIUEeKovM8ingMMQQ"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_0CRggNIUEeKovM8ingMMQQ" value="*"/>
+        </ownedParameter>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_8L56ENIUEeKovM8ingMMQQ" name="getViewPropertyValues">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_8L56EdIUEeKovM8ingMMQQ">
+          <body>Get the property values associated to the specified view.</body>
+        </ownedComment>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_8L56EtIUEeKovM8ingMMQQ" name="view" type="_j52EYNIUEeKovM8ingMMQQ"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_8L56E9IUEeKovM8ingMMQQ" name="result" type="_l4yNkM-0EeKO_rl5MA6s9A" direction="return">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_8L56FNIUEeKovM8ingMMQQ"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_8L56FdIUEeKovM8ingMMQQ" value="*"/>
+        </ownedParameter>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_LDqYgNIVEeKovM8ingMMQQ" name="getViewsPropertyValues">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_LDqYgdIVEeKovM8ingMMQQ">
+          <body>Get the property values associated to the specified view.</body>
+        </ownedComment>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_LDqYgtIVEeKovM8ingMMQQ" name="view" type="_j52EYNIUEeKovM8ingMMQQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_ZfK_0NIVEeKovM8ingMMQQ"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Zfl2kNIVEeKovM8ingMMQQ" value="*"/>
+        </ownedParameter>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_LDqYg9IVEeKovM8ingMMQQ" name="views" type="_j52EYNIUEeKovM8ingMMQQ" direction="return">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_LDqYhNIVEeKovM8ingMMQQ"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_LDqYhdIVEeKovM8ingMMQQ" value="*"/>
+        </ownedParameter>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_NfaCMNIVEeKovM8ingMMQQ" name="values" type="_l4yNkM-0EeKO_rl5MA6s9A" direction="return">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_NfaCMdIVEeKovM8ingMMQQ"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_NfaCMtIVEeKovM8ingMMQQ" value="*"/>
+        </ownedParameter>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_SH5a0NIWEeKovM8ingMMQQ" name="getAvailableProperties">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_SH5a0dIWEeKovM8ingMMQQ">
+          <body>Get the property descriptors available from</body>
+        </ownedComment>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_SH5a09IWEeKovM8ingMMQQ" name="result" type="_UzekYM-yEeKO_rl5MA6s9A" direction="return">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_SH5a1NIWEeKovM8ingMMQQ"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_SH5a1dIWEeKovM8ingMMQQ" value="*"/>
+        </ownedParameter>
+      </ownedOperation>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_saCQ4M-wEeKO_rl5MA6s9A" name="LayerOperatorExpression" isAbstract="true">
+      <generalization xmi:type="uml:Generalization" xmi:id="_w9X5MM-wEeKO_rl5MA6s9A" general="_q3GegM-wEeKO_rl5MA6s9A"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_Jk2f4NIPEeKovM8ingMMQQ" name="expressions" type="_q3GegM-wEeKO_rl5MA6s9A" aggregation="composite" association="_JlCtINIPEeKovM8ingMMQQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Jk2f4dIPEeKovM8ingMMQQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Jk2f4tIPEeKovM8ingMMQQ" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_uIcTcM-wEeKO_rl5MA6s9A" name="Layer" isAbstract="true">
+      <generalization xmi:type="uml:Generalization" xmi:id="_x2M-oM-wEeKO_rl5MA6s9A" general="_q3GegM-wEeKO_rl5MA6s9A"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_rl4TQM-0EeKO_rl5MA6s9A" name="views" type="_kextsM-0EeKO_rl5MA6s9A" association="_rmCEQM-0EeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_rl4TQc-0EeKO_rl5MA6s9A"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_rl4TQs-0EeKO_rl5MA6s9A" value="*"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_sdjiIM-0EeKO_rl5MA6s9A" name="propertyValues" type="_l4yNkM-0EeKO_rl5MA6s9A" isDerived="true" association="_sd2dEM-0EeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_sdjiIc-0EeKO_rl5MA6s9A"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_sdjiIs-0EeKO_rl5MA6s9A" value="*"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_PYT20NIQEeKovM8ingMMQQ" name="availableProperties" type="_UzekYM-yEeKO_rl5MA6s9A" isDerived="true" association="_PYgEENIQEeKovM8ingMMQQ">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_sI_z8NIQEeKovM8ingMMQQ">
+          <body>Return a list of properties that this layer support. This is a derived property (from Layer descriptor).</body>
+        </ownedComment>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_PYT20dIQEeKovM8ingMMQQ"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_PYT20tIQEeKovM8ingMMQQ" value="*"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_3x5JsNIQEeKovM8ingMMQQ" name="attachedProperties" type="_UzekYM-yEeKO_rl5MA6s9A" isDerived="true" association="_3yFW8NIQEeKovM8ingMMQQ">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_LuHnkNIREeKovM8ingMMQQ">
+          <body>Return a list of properties already attached to the Layer.&#xD;
+This is a derived property.</body>
+        </ownedComment>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_3x5JsdIQEeKovM8ingMMQQ"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_3x5JstIQEeKovM8ingMMQQ" value="*"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="__8qywNIQEeKovM8ingMMQQ" name="notAttachedProperties" type="_UzekYM-yEeKO_rl5MA6s9A" isDerived="true" association="__8-UwNIQEeKovM8ingMMQQ">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_ZhROYNIREeKovM8ingMMQQ">
+          <body>Return a list of not already attached properties. This is a derived property.</body>
+        </ownedComment>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="__8qywdIQEeKovM8ingMMQQ"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="__8qywtIQEeKovM8ingMMQQ" value="*"/>
+      </ownedAttribute>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_AYzD8NeJEeKpd73UUMObaQ" name="setPropertyValue">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_HezdUNeJEeKpd73UUMObaQ" name="index" type="_-DoC8NIPEeKovM8ingMMQQ"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_LoMUkNeJEeKpd73UUMObaQ" name="value" type="_NwL70NeJEeKpd73UUMObaQ" direction="inout"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_aJy80NeJEeKpd73UUMObaQ" name="setPropertyValue">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_aJy80deJEeKpd73UUMObaQ" name="name" type="_70TEoNIPEeKovM8ingMMQQ"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_aJy80teJEeKpd73UUMObaQ" name="value" type="_NwL70NeJEeKpd73UUMObaQ" direction="inout"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_aou7kNeJEeKpd73UUMObaQ" name="setPropertyValue">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_aou7kdeJEeKpd73UUMObaQ" name="propDesc" type="_UzekYM-yEeKO_rl5MA6s9A"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_aou7kteJEeKpd73UUMObaQ" name="value" type="_NwL70NeJEeKpd73UUMObaQ" direction="inout"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_urYKgNeJEeKpd73UUMObaQ" name="getPropertyValue">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_urYKgdeJEeKpd73UUMObaQ" name="name" type="_70TEoNIPEeKovM8ingMMQQ"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_urYKgteJEeKpd73UUMObaQ" name="value" type="_NwL70NeJEeKpd73UUMObaQ" direction="return"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_urhUcNeJEeKpd73UUMObaQ" name="getPropertyValue">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_urhUcdeJEeKpd73UUMObaQ" name="index" type="_-DoC8NIPEeKovM8ingMMQQ"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_urhUcteJEeKpd73UUMObaQ" name="value" type="_NwL70NeJEeKpd73UUMObaQ" direction="return"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_uropMNeJEeKpd73UUMObaQ" name="getPropertyValue">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_urpQQNeJEeKpd73UUMObaQ" name="propDesc" type="_UzekYM-yEeKO_rl5MA6s9A"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_urpQQdeJEeKpd73UUMObaQ" name="value" type="_NwL70NeJEeKpd73UUMObaQ" direction="return"/>
+      </ownedOperation>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_zRG2YM-wEeKO_rl5MA6s9A" name="Class1" isAbstract="true">
+      <generalization xmi:type="uml:Generalization" xmi:id="_pd8dwM-xEeKO_rl5MA6s9A" general="_saCQ4M-wEeKO_rl5MA6s9A"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_awVkYM-yEeKO_rl5MA6s9A" name="propertyOperators" type="_SZ1McM-yEeKO_rl5MA6s9A" aggregation="composite" association="_awpGYM-yEeKO_rl5MA6s9A">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_KvpSgM-zEeKO_rl5MA6s9A">
+          <body>Collection of property operators used to compute two operands. Each property operator is designed to &#xD;
+operate on one type of property.</body>
+        </ownedComment>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_awVkYc-yEeKO_rl5MA6s9A"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_awVkYs-yEeKO_rl5MA6s9A" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_cLZCkM-xEeKO_rl5MA6s9A" name="CustomOperator">
+      <generalization xmi:type="uml:Generalization" xmi:id="_ooh4sM-xEeKO_rl5MA6s9A" general="_saCQ4M-wEeKO_rl5MA6s9A"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_hp55sM-xEeKO_rl5MA6s9A" name="StackedOperator">
+      <generalization xmi:type="uml:Generalization" xmi:id="_qGHRAM-xEeKO_rl5MA6s9A" general="_zRG2YM-wEeKO_rl5MA6s9A"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_jAMXMM-xEeKO_rl5MA6s9A" name="TopOperator">
+      <generalization xmi:type="uml:Generalization" xmi:id="_quvXQM-xEeKO_rl5MA6s9A" general="_zRG2YM-wEeKO_rl5MA6s9A"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_t0KQEM-xEeKO_rl5MA6s9A" name="SimpleLayer">
+      <generalization xmi:type="uml:Generalization" xmi:id="_yiCUcM-xEeKO_rl5MA6s9A" general="_uIcTcM-wEeKO_rl5MA6s9A"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_u6-HIM-xEeKO_rl5MA6s9A" name="RegExpLayer">
+      <generalization xmi:type="uml:Generalization" xmi:id="_zKNHsM-xEeKO_rl5MA6s9A" general="_uIcTcM-wEeKO_rl5MA6s9A"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_pRx2AFzHEeOeP67GJGKDkA" name="expressionMatcher" type="_sc15QFzGEeOeP67GJGKDkA" aggregation="composite" association="_pR38oFzHEeOeP67GJGKDkA">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_pRx2AVzHEeOeP67GJGKDkA" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_pRx2AlzHEeOeP67GJGKDkA" value="1"/>
+      </ownedAttribute>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_LTBBsEysEeObF6ELIGKT-g" name="computeExpression"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_SZ1McM-yEeKO_rl5MA6s9A" name="PropertyOperator" isAbstract="true">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_lk1MQM-zEeKO_rl5MA6s9A">
+        <body>An operator used to compute two operands. The operator is designed to operate on specified property.</body>
+      </ownedComment>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_mjPKsM-yEeKO_rl5MA6s9A" name="propertyDescriptor" type="_UzekYM-yEeKO_rl5MA6s9A" association="_mjiFoM-yEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_mjPKsc-yEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_mjPKss-yEeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_UzekYM-yEeKO_rl5MA6s9A" name="PropertyDescriptor">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_xNNKINIPEeKovM8ingMMQQ" name="name" visibility="public" type="_70TEoNIPEeKovM8ingMMQQ" isUnique="false">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_CadgUNIQEeKovM8ingMMQQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_CariwNIQEeKovM8ingMMQQ" value="1"/>
+        <defaultValue xmi:type="uml:LiteralString" xmi:id="_CbWRINIQEeKovM8ingMMQQ">
+          <value xsi:nil="true"/>
+        </defaultValue>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_C8tRwNIQEeKovM8ingMMQQ" name="icon" visibility="public" type="_GiHSMNIQEeKovM8ingMMQQ" isUnique="false">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_JxGWsNIQEeKovM8ingMMQQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_JxYqkNIQEeKovM8ingMMQQ" value="1"/>
+        <defaultValue xmi:type="uml:LiteralString" xmi:id="_JyDY8NIQEeKovM8ingMMQQ">
+          <value xsi:nil="true"/>
+        </defaultValue>
+      </ownedAttribute>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_cX5PQNeNEeKpd73UUMObaQ" name="defaultValue" type="_l4yNkM-0EeKO_rl5MA6s9A" aggregation="composite" association="_cYKVANeNEeKpd73UUMObaQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_cX5PQdeNEeKpd73UUMObaQ"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_cX5PQteNEeKpd73UUMObaQ" value="1"/>
+      </ownedAttribute>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_NDsscNeNEeKpd73UUMObaQ" name="newPropertyValueInstance"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_awpGYM-yEeKO_rl5MA6s9A" name="class1_propertyOperator_1" memberEnd="_awpGYc-yEeKO_rl5MA6s9A _awVkYM-yEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_awpGYc-yEeKO_rl5MA6s9A" name="class1" type="_zRG2YM-wEeKO_rl5MA6s9A" association="_awpGYM-yEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_awpGYs-yEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_awpGY8-yEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_mjiFoM-yEeKO_rl5MA6s9A" name="propertyOperator_propertyDescriptor_1" memberEnd="_mjiFoc-yEeKO_rl5MA6s9A _mjPKsM-yEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_mjiFoc-yEeKO_rl5MA6s9A" name="propertyOperator" type="_SZ1McM-yEeKO_rl5MA6s9A" association="_mjiFoM-yEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_mjiFos-yEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_mjiFo8-yEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_kextsM-0EeKO_rl5MA6s9A" name="View"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_l4yNkM-0EeKO_rl5MA6s9A" name="TypeValue">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_OFQ7wM-5EeKO_rl5MA6s9A" name="descriptor" type="_UzekYM-yEeKO_rl5MA6s9A" association="_OFj2sM-5EeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_OFQ7wc-5EeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_OFQ7ws-5EeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_rmCEQM-0EeKO_rl5MA6s9A" name="layer_view_1" memberEnd="_rmCEQc-0EeKO_rl5MA6s9A _rl4TQM-0EeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_rmCEQc-0EeKO_rl5MA6s9A" name="layer" type="_uIcTcM-wEeKO_rl5MA6s9A" association="_rmCEQM-0EeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_rmCEQs-0EeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_rmCEQ8-0EeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_sd2dEM-0EeKO_rl5MA6s9A" name="layer_propertyValue_1" memberEnd="_sd2dEc-0EeKO_rl5MA6s9A _sdjiIM-0EeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_sd2dEc-0EeKO_rl5MA6s9A" name="layer" type="_uIcTcM-wEeKO_rl5MA6s9A" association="_sd2dEM-0EeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_sd2dEs-0EeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_sd2dE8-0EeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_OFj2sM-5EeKO_rl5MA6s9A" name="propertyValue_propertyDescriptor_1" memberEnd="_OFj2sc-5EeKO_rl5MA6s9A _OFQ7wM-5EeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_OFj2sc-5EeKO_rl5MA6s9A" name="propertyValue" type="_l4yNkM-0EeKO_rl5MA6s9A" association="_OFj2sM-5EeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_OFj2ss-5EeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_OFj2s8-5EeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_JlCtINIPEeKovM8ingMMQQ" name="operatorExpression_layerExpression_1" memberEnd="_JlCtIdIPEeKovM8ingMMQQ _Jk2f4NIPEeKovM8ingMMQQ">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_JlCtIdIPEeKovM8ingMMQQ" name="operatorExpression" type="_saCQ4M-wEeKO_rl5MA6s9A" association="_JlCtINIPEeKovM8ingMMQQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_JlCtItIPEeKovM8ingMMQQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_JlCtI9IPEeKovM8ingMMQQ" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_PYgEENIQEeKovM8ingMMQQ" name="layer_propertyDescriptor_1" memberEnd="_PYgEEdIQEeKovM8ingMMQQ _PYT20NIQEeKovM8ingMMQQ">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_PYgEEdIQEeKovM8ingMMQQ" name="layer" type="_q3GegM-wEeKO_rl5MA6s9A" association="_PYgEENIQEeKovM8ingMMQQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_PYgEEtIQEeKovM8ingMMQQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_PYgEE9IQEeKovM8ingMMQQ" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_3yFW8NIQEeKovM8ingMMQQ" name="layerExpression_propertyDescriptor_2" memberEnd="_3yFW8dIQEeKovM8ingMMQQ _3x5JsNIQEeKovM8ingMMQQ">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_3yFW8dIQEeKovM8ingMMQQ" name="expr" type="_q3GegM-wEeKO_rl5MA6s9A" association="_3yFW8NIQEeKovM8ingMMQQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_3yFW8tIQEeKovM8ingMMQQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_3yFW89IQEeKovM8ingMMQQ" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="__8-UwNIQEeKovM8ingMMQQ" name="layer_propertyDescriptor_3" memberEnd="__8-UwdIQEeKovM8ingMMQQ __8qywNIQEeKovM8ingMMQQ">
+      <ownedEnd xmi:type="uml:Property" xmi:id="__8-UwdIQEeKovM8ingMMQQ" name="layer" type="_uIcTcM-wEeKO_rl5MA6s9A" association="__8-UwNIQEeKovM8ingMMQQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="__8-UwtIQEeKovM8ingMMQQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="__8-Uw9IQEeKovM8ingMMQQ" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_unRJANIXEeKovM8ingMMQQ" name="layerExpression_view_1" memberEnd="_unRJAdIXEeKovM8ingMMQQ _unLCYNIXEeKovM8ingMMQQ">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_unRJAdIXEeKovM8ingMMQQ" name="layerExpression" type="_q3GegM-wEeKO_rl5MA6s9A" association="_unRJANIXEeKovM8ingMMQQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_unRJAtIXEeKovM8ingMMQQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_unRJA9IXEeKovM8ingMMQQ" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_3qy5UNNnEeKwWoA8j13SIg" name="LayerStacks">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_QvVU0NNoEeKwWoA8j13SIg">
+        <body>Entry point of the model.&#xD;
+LayerStack are associated to their diagram.&#xD;
+</body>
+      </ownedComment>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_8-4CENNnEeKwWoA8j13SIg" name="layerStacks" type="_t0NNoM9UEeKO_rl5MA6s9A" aggregation="composite" association="_8_KV8NNnEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_8-4CEdNnEeKwWoA8j13SIg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_8-4CEtNnEeKwWoA8j13SIg" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_8_KV8NNnEeKwWoA8j13SIg" name="layerStacks_layerStack_1" memberEnd="_8_KV8dNnEeKwWoA8j13SIg _8-4CENNnEeKwWoA8j13SIg">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_8_KV8dNnEeKwWoA8j13SIg" name="layerStacks" type="_3qy5UNNnEeKwWoA8j13SIg" association="_8_KV8NNnEeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_8_KV8tNnEeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_8_KV89NnEeKwWoA8j13SIg" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_iOVr4NN0EeKwWoA8j13SIg" name="SelectionManager">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_Rkak4NN3EeKwWoA8j13SIg">
+        <body>This class is used to maintain the current layer selected.&#xD;
+It listen on LayerStack event, and set the current layer accordingly.&#xD;
+The current layer can also be set by methods.&#xD;
+The class can be observed to listen to selection changed.</body>
+      </ownedComment>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_zPQPMNN0EeKwWoA8j13SIg" name="currentLayer" visibility="public" type="_uIcTcM-wEeKO_rl5MA6s9A" isUnique="false">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_2bmPYNN0EeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_2b4jQNN0EeKwWoA8j13SIg" value="1"/>
+        <defaultValue xmi:type="uml:LiteralString" xmi:id="_2cu30NN0EeKwWoA8j13SIg">
+          <value xsi:nil="true"/>
+        </defaultValue>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_4CAMgNN0EeKwWoA8j13SIg" name="layerStack_selectionManager_1" memberEnd="_4CAMgdN0EeKwWoA8j13SIg _4B6F4NN0EeKwWoA8j13SIg">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_4CAMgdN0EeKwWoA8j13SIg" name="layerStack" type="_t0NNoM9UEeKO_rl5MA6s9A" association="_4CAMgNN0EeKwWoA8j13SIg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_4CAMgtN0EeKwWoA8j13SIg" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_4CAMg9N0EeKwWoA8j13SIg" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Interface" xmi:id="_OS41oNNqEeKwWoA8j13SIg" clientDependency="_TW8v8NNrEeKwWoA8j13SIg _XY1RANNrEeKwWoA8j13SIg" name="ILayersModelEventListener">
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_SmexwNNqEeKwWoA8j13SIg" name="propertyValueAdded">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_eeKKYNNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_htRxwNNqEeKwWoA8j13SIg" name="propertyValueRemoved">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_htRxwdNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_h5JDgNNqEeKwWoA8j13SIg" name="propertyValueChanged">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_h5JDgdNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_h69BYNNqEeKwWoA8j13SIg" name="layerAdded">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_h69BYdNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_iGe78NNqEeKwWoA8j13SIg" name="layerRemoved">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_iGe78dNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_iKn1ENNqEeKwWoA8j13SIg" name="layerMoved">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_iKn1EdNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_iUNO4NNqEeKwWoA8j13SIg" name="layerStackEnable">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_iUNO4dNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_1WChENNqEeKwWoA8j13SIg" name="layerStackDisable">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_1WChEdNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_1iV3sNNqEeKwWoA8j13SIg" name="viewAddedToLayer">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_1iV3sdNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_1mcUkNNqEeKwWoA8j13SIg" name="viewRemovedFromLayer">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_1mcUkdNqEeKwWoA8j13SIg" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_94G1IN9lEeKCZbxNW-U3VQ" name="viewMovedBetweenLayers">
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_94G1Id9lEeKCZbxNW-U3VQ" name="event" type="_XbvQgNNqEeKwWoA8j13SIg"/>
+      </ownedOperation>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_XbvQgNNqEeKwWoA8j13SIg" name="LayersModelEvent"/>
+    <packagedElement xmi:type="uml:Dependency" xmi:id="_TW8v8NNrEeKwWoA8j13SIg" name="listenOn" client="_OS41oNNqEeKwWoA8j13SIg" supplier="_t0NNoM9UEeKO_rl5MA6s9A"/>
+    <packagedElement xmi:type="uml:Dependency" xmi:id="_XY1RANNrEeKwWoA8j13SIg" name="Dependency2" client="_OS41oNNqEeKwWoA8j13SIg" supplier="_XbvQgNNqEeKwWoA8j13SIg"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_WMWIcNeMEeKpd73UUMObaQ" name="PropertyFactory">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_H-rd8NeOEeKpd73UUMObaQ" name="propertyDescriptors" type="_UzekYM-yEeKO_rl5MA6s9A" association="_H-9x0NeOEeKpd73UUMObaQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_H-rd8deOEeKpd73UUMObaQ"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_H-rd8teOEeKpd73UUMObaQ" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_cYKVANeNEeKpd73UUMObaQ" name="propertyDescriptor_propertyValue_1" memberEnd="_cYKVAdeNEeKpd73UUMObaQ _cX5PQNeNEeKpd73UUMObaQ">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_cYKVAdeNEeKpd73UUMObaQ" name="propertyDescriptor" type="_UzekYM-yEeKO_rl5MA6s9A" association="_cYKVANeNEeKpd73UUMObaQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_cYKVAteNEeKpd73UUMObaQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_cYKVA9eNEeKpd73UUMObaQ" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_H-9x0NeOEeKpd73UUMObaQ" name="propertyFactory_propertyDescriptor_1" memberEnd="_H-9x0deOEeKpd73UUMObaQ _H-rd8NeOEeKpd73UUMObaQ">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_H-9x0deOEeKpd73UUMObaQ" name="propertyFactory" type="_WMWIcNeMEeKpd73UUMObaQ" association="_H-9x0NeOEeKpd73UUMObaQ">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_H-9x0teOEeKpd73UUMObaQ" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_H-9x09eOEeKpd73UUMObaQ" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Package" xmi:id="_Gkz8QEyjEeObF6ELIGKT-g" name="notifiers">
+      <packagedElement xmi:type="uml:Class" xmi:id="_JwRLoEyjEeObF6ELIGKT-g" clientDependency="_SokpEEyjEeObF6ELIGKT-g" name="DiagramViewEventNotifier">
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_h14fwEyuEeObF6ELIGKT-g" name="stopListening"/>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_h15G0EyuEeObF6ELIGKT-g" name="startListening"/>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Interface" xmi:id="_HJLoANNqEeKwWoA8j13SIg" name="IDiagramViewEventListener">
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_JZ7ioNNqEeKwWoA8j13SIg" name="viewAddedEvent"/>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_Ft6TwN9mEeKCZbxNW-U3VQ" name="viewRemovedEvent"/>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Usage" xmi:id="_SokpEEyjEeObF6ELIGKT-g" name="Usage1" client="_JwRLoEyjEeObF6ELIGKT-g" supplier="_HJLoANNqEeKwWoA8j13SIg"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_pR38oFzHEeOeP67GJGKDkA" name="regExpLayer_expressionMatcher_1" memberEnd="_pR38oVzHEeOeP67GJGKDkA _pRx2AFzHEeOeP67GJGKDkA">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_pR38oVzHEeOeP67GJGKDkA" name="regExpLayer" type="_u6-HIM-xEeKO_rl5MA6s9A" association="_pR38oFzHEeOeP67GJGKDkA">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_pR38olzHEeOeP67GJGKDkA" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_pR38o1zHEeOeP67GJGKDkA" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Package" xmi:id="_ShE8QL2QEeKKJJ5BmR3W3Q" name="notation">
+    <packagedElement xmi:type="uml:Class" xmi:id="_rqknoM9UEeKO_rl5MA6s9A" name="Diagram">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_5PP4IM9VEeKO_rl5MA6s9A" name="namedStyle" type="_0Q5HwM9VEeKO_rl5MA6s9A" association="_5PcFYM9VEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_5PP4Ic9VEeKO_rl5MA6s9A"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_5PP4Is9VEeKO_rl5MA6s9A" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_5PcFYM9VEeKO_rl5MA6s9A" name="diagram_namedStyle_1" memberEnd="_5PcFYc9VEeKO_rl5MA6s9A _5PP4IM9VEeKO_rl5MA6s9A">
+      <ownedEnd xmi:type="uml:Property" xmi:id="_5PcFYc9VEeKO_rl5MA6s9A" name="diagram" type="_rqknoM9UEeKO_rl5MA6s9A" association="_5PcFYM9VEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_5PcFYs9VEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_5PcFY89VEeKO_rl5MA6s9A" value="1"/>
+      </ownedEnd>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_0Q5HwM9VEeKO_rl5MA6s9A" name="NamedStyle">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_54-KkM9VEeKO_rl5MA6s9A" name="value" type="_t0NNoM9UEeKO_rl5MA6s9A" association="_55Ll8M9VEeKO_rl5MA6s9A">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_54-Kkc9VEeKO_rl5MA6s9A" value="1"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_54-Kks9VEeKO_rl5MA6s9A" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_j52EYNIUEeKovM8ingMMQQ" name="View"/>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Package" xmi:id="_4GLNENIPEeKovM8ingMMQQ" name="datatypes">
+    <packagedElement xmi:type="uml:PrimitiveType" xmi:id="_70TEoNIPEeKovM8ingMMQQ" name="String"/>
+    <packagedElement xmi:type="uml:PrimitiveType" xmi:id="_9KgpoNIPEeKovM8ingMMQQ" name="boolean"/>
+    <packagedElement xmi:type="uml:PrimitiveType" xmi:id="_-DoC8NIPEeKovM8ingMMQQ" name="int"/>
+    <packagedElement xmi:type="uml:PrimitiveType" xmi:id="_GiHSMNIQEeKovM8ingMMQQ" name="Icon"/>
+    <packagedElement xmi:type="uml:PrimitiveType" xmi:id="_NwL70NeJEeKpd73UUMObaQ" name="Object"/>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Model" xmi:id="_3PV9kNLREeKwWoA8j13SIg" name="patterns">
+    <packagedElement xmi:type="uml:Package" xmi:id="_93lc4NLREeKwWoA8j13SIg" name="eventProviderOneListener">
+      <packagedElement xmi:type="uml:Class" xmi:id="_FpeE0NLSEeKwWoA8j13SIg" clientDependency="_vlovUNLTEeKwWoA8j13SIg" name="ClassnameEventProvider">
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_qQgTINLSEeKwWoA8j13SIg" name="eventListener" type="_MFiwYNLSEeKwWoA8j13SIg" association="_qQmZwNLSEeKwWoA8j13SIg">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_qQgTIdLSEeKwWoA8j13SIg"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_qQgTItLSEeKwWoA8j13SIg" value="1"/>
+        </ownedAttribute>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="___ERUNLSEeKwWoA8j13SIg" name="addClassnameEventListener">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_K04kUNLTEeKwWoA8j13SIg" name="listener" type="_MFiwYNLSEeKwWoA8j13SIg"/>
+        </ownedOperation>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_OXuY8NLTEeKwWoA8j13SIg" name="removeClassnameEventListener">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_OXuY8dLTEeKwWoA8j13SIg" name="listener" type="_MFiwYNLSEeKwWoA8j13SIg"/>
+        </ownedOperation>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_c-YVwNLSEeKwWoA8j13SIg" name="fireName1Event">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_k6tTINLSEeKwWoA8j13SIg" name="event" type="_TqDqsNLSEeKwWoA8j13SIg"/>
+        </ownedOperation>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_dAOTYNLTEeKwWoA8j13SIg" name="fireName2Event">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_dAOTYdLTEeKwWoA8j13SIg" name="event" type="_TqDqsNLSEeKwWoA8j13SIg"/>
+        </ownedOperation>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Interface" xmi:id="_MFiwYNLSEeKwWoA8j13SIg" clientDependency="_wSvs8NLTEeKwWoA8j13SIg" name="IClassnameEventListener">
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_7UNrwNLSEeKwWoA8j13SIg" name="name1Event">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_7UNrwdLSEeKwWoA8j13SIg" name="event" type="_TqDqsNLSEeKwWoA8j13SIg"/>
+        </ownedOperation>
+        <ownedOperation xmi:type="uml:Operation" xmi:id="_hnQI4NLTEeKwWoA8j13SIg" name="name2Event">
+          <ownedParameter xmi:type="uml:Parameter" xmi:id="_hnQI4dLTEeKwWoA8j13SIg" name="event" type="_TqDqsNLSEeKwWoA8j13SIg"/>
+        </ownedOperation>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_TqDqsNLSEeKwWoA8j13SIg" name="ClassnameEvent">
+        <ownedComment xmi:type="uml:Comment" xmi:id="_1Q1-oNLTEeKwWoA8j13SIg">
+          <body>The Event class is used to carry data from the sender to the listener.</body>
+        </ownedComment>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_qQmZwNLSEeKwWoA8j13SIg" name="classnameEventProvider_iClassnameEventListener_1" memberEnd="_qQmZwdLSEeKwWoA8j13SIg _qQgTINLSEeKwWoA8j13SIg">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_qQmZwdLSEeKwWoA8j13SIg" name="classnameEventProvider" type="_FpeE0NLSEeKwWoA8j13SIg" association="_qQmZwNLSEeKwWoA8j13SIg">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_qQmZwtLSEeKwWoA8j13SIg" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_qQmZw9LSEeKwWoA8j13SIg" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Dependency" xmi:id="_vlovUNLTEeKwWoA8j13SIg" name="Dependency1" client="_FpeE0NLSEeKwWoA8j13SIg" supplier="_TqDqsNLSEeKwWoA8j13SIg"/>
+      <packagedElement xmi:type="uml:Dependency" xmi:id="_wSvs8NLTEeKwWoA8j13SIg" name="" client="_MFiwYNLSEeKwWoA8j13SIg" supplier="_TqDqsNLSEeKwWoA8j13SIg"/>
+    </packagedElement>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Model" xmi:id="_Hq1QwNRgEeKHbZ6TDsPmrQ" name="design">
+    <packagedElement xmi:type="uml:Package" xmi:id="_MIZBMNRgEeKHbZ6TDsPmrQ" name="extensible properties">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_8tJPoNRpEeKHbZ6TDsPmrQ">
+        <body>Type and TypeValue are part of the system ?</body>
+      </ownedComment>
+      <ownedComment xmi:type="uml:Comment" xmi:id="_4zs_QNRxEeKHbZ6TDsPmrQ">
+        <body>LayerDescriptor and Property are not saved with LayerStack</body>
+      </ownedComment>
+      <packagedElement xmi:type="uml:Class" xmi:id="_WWBS0NRgEeKHbZ6TDsPmrQ" name="Property">
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_bo_oUNRgEeKHbZ6TDsPmrQ" name="type" type="_XqHX8NRgEeKHbZ6TDsPmrQ" association="_bpFu8NRgEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_bo_oUdRgEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_bo_oUtRgEeKHbZ6TDsPmrQ" value="1"/>
+        </ownedAttribute>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_h2j90NRgEeKHbZ6TDsPmrQ" name="name" visibility="public" type="_70TEoNIPEeKovM8ingMMQQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_ko6JoNRgEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_kpG98NRgEeKHbZ6TDsPmrQ" value="1"/>
+          <defaultValue xmi:type="uml:LiteralString" xmi:id="_kp95kNRgEeKHbZ6TDsPmrQ">
+            <value xsi:nil="true"/>
+          </defaultValue>
+        </ownedAttribute>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_XqHX8NRgEeKHbZ6TDsPmrQ" name="Type"/>
+      <packagedElement xmi:type="uml:Class" xmi:id="_Y8NR8NRgEeKHbZ6TDsPmrQ" name="PropertyValue">
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_HqSBsNRhEeKHbZ6TDsPmrQ" name="typeValue" type="_F0T-kNRhEeKHbZ6TDsPmrQ" association="_HqkVkNRhEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_HqSBsdRhEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_HqSBstRhEeKHbZ6TDsPmrQ" value="1"/>
+        </ownedAttribute>
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_IvGUsNRhEeKHbZ6TDsPmrQ" name="property" type="_WWBS0NRgEeKHbZ6TDsPmrQ" association="_IvSh8NRhEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_IvGUsdRhEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_IvGUstRhEeKHbZ6TDsPmrQ" value="1"/>
+        </ownedAttribute>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_bpFu8NRgEeKHbZ6TDsPmrQ" name="property_type_1" memberEnd="_bpFu8dRgEeKHbZ6TDsPmrQ _bo_oUNRgEeKHbZ6TDsPmrQ">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_bpFu8dRgEeKHbZ6TDsPmrQ" name="property" type="_WWBS0NRgEeKHbZ6TDsPmrQ" association="_bpFu8NRgEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_bpFu8tRgEeKHbZ6TDsPmrQ"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_bpFu89RgEeKHbZ6TDsPmrQ" value="*"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_dFTOQNRgEeKHbZ6TDsPmrQ" name="LayerDescriptor">
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_gXohsNRgEeKHbZ6TDsPmrQ" name="AllowedProperties" type="_WWBS0NRgEeKHbZ6TDsPmrQ" aggregation="composite" association="_gX0u8NRgEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_gXohsdRgEeKHbZ6TDsPmrQ"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_gXohstRgEeKHbZ6TDsPmrQ" value="*"/>
+        </ownedAttribute>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_gX0u8NRgEeKHbZ6TDsPmrQ" name="layerDescriptor_property_1" memberEnd="_gX0u8dRgEeKHbZ6TDsPmrQ _gXohsNRgEeKHbZ6TDsPmrQ">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_gX0u8dRgEeKHbZ6TDsPmrQ" name="layerDescriptor" type="_dFTOQNRgEeKHbZ6TDsPmrQ" association="_gX0u8NRgEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_gX0u8tRgEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_gX0u89RgEeKHbZ6TDsPmrQ" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_BrSTsNRhEeKHbZ6TDsPmrQ" name="Layer">
+        <ownedAttribute xmi:type="uml:Property" xmi:id="_EeaioNRhEeKHbZ6TDsPmrQ" name="propertyValue" type="_Y8NR8NRgEeKHbZ6TDsPmrQ" association="_Eemv4NRhEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_EeaiodRhEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_EeaiotRhEeKHbZ6TDsPmrQ" value="1"/>
+        </ownedAttribute>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_Eemv4NRhEeKHbZ6TDsPmrQ" name="layer_propertyValue_1" memberEnd="_Eemv4dRhEeKHbZ6TDsPmrQ _EeaioNRhEeKHbZ6TDsPmrQ">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_Eemv4dRhEeKHbZ6TDsPmrQ" name="layer" type="_BrSTsNRhEeKHbZ6TDsPmrQ" association="_Eemv4NRhEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Eemv4tRhEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Eemv49RhEeKHbZ6TDsPmrQ" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Class" xmi:id="_F0T-kNRhEeKHbZ6TDsPmrQ" name="TypeValue"/>
+      <packagedElement xmi:type="uml:Association" xmi:id="_HqkVkNRhEeKHbZ6TDsPmrQ" name="propertyValue_typeValue_1" memberEnd="_HqkVkdRhEeKHbZ6TDsPmrQ _HqSBsNRhEeKHbZ6TDsPmrQ">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_HqkVkdRhEeKHbZ6TDsPmrQ" name="propertyValue" type="_Y8NR8NRgEeKHbZ6TDsPmrQ" association="_HqkVkNRhEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_HqkVktRhEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_HqkVk9RhEeKHbZ6TDsPmrQ" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+      <packagedElement xmi:type="uml:Association" xmi:id="_IvSh8NRhEeKHbZ6TDsPmrQ" name="propertyValue_property_1" memberEnd="_IvSh8dRhEeKHbZ6TDsPmrQ _IvGUsNRhEeKHbZ6TDsPmrQ">
+        <ownedEnd xmi:type="uml:Property" xmi:id="_IvSh8dRhEeKHbZ6TDsPmrQ" name="propertyValue" type="_Y8NR8NRgEeKHbZ6TDsPmrQ" association="_IvSh8NRhEeKHbZ6TDsPmrQ">
+          <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_IvSh8tRhEeKHbZ6TDsPmrQ" value="1"/>
+          <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_IvSh89RhEeKHbZ6TDsPmrQ" value="1"/>
+        </ownedEnd>
+      </packagedElement>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Model" xmi:id="_pa8XAHh8EeOlpfB_tZS-QA" name="layers life cycle">
+      <packagedElement xmi:type="uml:StateMachine" xmi:id="_sqYugHh8EeOlpfB_tZS-QA" name="StateMachine1">
+        <region xmi:type="uml:Region" xmi:id="_uQQgIHh8EeOlpfB_tZS-QA" name="Region1">
+          <ownedComment xmi:type="uml:Comment" xmi:id="_A8brYHh9EeOlpfB_tZS-QA" annotatedElement="_5CvLQHh8EeOlpfB_tZS-QA">
+            <body>Attached to a LayersStack.&#xD;
+All attributes are set: &#xD;
+ - owningLayersStack&#xD;
+ - application&#xD;
+ - parent/container&#xD;
+</body>
+          </ownedComment>
+          <transition xmi:type="uml:Transition" xmi:id="_QzWgwHh9EeOlpfB_tZS-QA" name="createLayerXxx()" source="_vdgWYHh8EeOlpfB_tZS-QA" target="_wpIcAHh8EeOlpfB_tZS-QA"/>
+          <transition xmi:type="uml:Transition" xmi:id="_T3PIgHh9EeOlpfB_tZS-QA" name="model.load()" source="_SOtrgHh9EeOlpfB_tZS-QA" target="_1L6DoHh8EeOlpfB_tZS-QA"/>
+          <transition xmi:type="uml:Transition" xmi:id="_Wz5G4Hh9EeOlpfB_tZS-QA" name="detach()" source="_5CvLQHh8EeOlpfB_tZS-QA" target="_88sfYHh8EeOlpfB_tZS-QA"/>
+          <transition xmi:type="uml:Transition" xmi:id="_X_U_QHh9EeOlpfB_tZS-QA" name="attach(diagramProvider)" source="_88sfYHh8EeOlpfB_tZS-QA" target="_5CvLQHh8EeOlpfB_tZS-QA">
+            <trigger xmi:type="uml:Trigger" xmi:id="_YoUxkHiAEeOlpfB_tZS-QA" name="attach(DiagramProvider)"/>
+            <trigger xmi:type="uml:Trigger" xmi:id="_ca2A8HiAEeOlpfB_tZS-QA" name="attach(DiagramProvider, Application)"/>
+          </transition>
+          <transition xmi:type="uml:Transition" xmi:id="_ZpOVQHh9EeOlpfB_tZS-QA" name="parent.add" source="_wpIcAHh8EeOlpfB_tZS-QA" target="_5CvLQHh8EeOlpfB_tZS-QA">
+            <trigger xmi:type="uml:Trigger" xmi:id="_teoZcHh9EeOlpfB_tZS-QA" name="parent.layers.add"/>
+          </transition>
+          <transition xmi:type="uml:Transition" xmi:id="_a0LsgHh9EeOlpfB_tZS-QA" name="startAfterReload()" source="_1L6DoHh8EeOlpfB_tZS-QA" target="_5CvLQHh8EeOlpfB_tZS-QA"/>
+          <subvertex xmi:type="uml:Pseudostate" xmi:id="_vdgWYHh8EeOlpfB_tZS-QA" name="create"/>
+          <subvertex xmi:type="uml:State" xmi:id="_wpIcAHh8EeOlpfB_tZS-QA" name="created"/>
+          <subvertex xmi:type="uml:State" xmi:id="_1L6DoHh8EeOlpfB_tZS-QA" name="reloaded"/>
+          <subvertex xmi:type="uml:State" xmi:id="_5CvLQHh8EeOlpfB_tZS-QA" name="attached"/>
+          <subvertex xmi:type="uml:State" xmi:id="_88sfYHh8EeOlpfB_tZS-QA" name="detached"/>
+          <subvertex xmi:type="uml:Pseudostate" xmi:id="_SOtrgHh9EeOlpfB_tZS-QA" name="load model"/>
+        </region>
+      </packagedElement>
+      <packagedElement xmi:type="uml:StateMachine" xmi:id="_E3DwEHiMEeOlpfB_tZS-QA" name="StateMachine2">
+        <region xmi:type="uml:Region" xmi:id="_GqKscHiMEeOlpfB_tZS-QA" name="Region1">
+          <transition xmi:type="uml:Transition" xmi:id="_QsmasHiMEeOlpfB_tZS-QA" name="Transition0" source="_IRX60HiMEeOlpfB_tZS-QA" target="_IqdJMHiMEeOlpfB_tZS-QA"/>
+          <transition xmi:type="uml:Transition" xmi:id="_S2BlUHiMEeOlpfB_tZS-QA" name="Transition1" source="_IqdJMHiMEeOlpfB_tZS-QA" target="_KcUvcHiMEeOlpfB_tZS-QA"/>
+          <transition xmi:type="uml:Transition" xmi:id="_T6ZzcHiMEeOlpfB_tZS-QA" name="Transition2" source="_IqdJMHiMEeOlpfB_tZS-QA" target="_M9r48HiMEeOlpfB_tZS-QA"/>
+          <transition xmi:type="uml:Transition" xmi:id="_VI4_0HiMEeOlpfB_tZS-QA" name="attach (all cond=true)" source="_M9r48HiMEeOlpfB_tZS-QA" target="_KcUvcHiMEeOlpfB_tZS-QA"/>
+          <transition xmi:type="uml:Transition" xmi:id="_WOy38HiMEeOlpfB_tZS-QA" name="detach" source="_KcUvcHiMEeOlpfB_tZS-QA" target="_M9r48HiMEeOlpfB_tZS-QA"/>
+          <subvertex xmi:type="uml:Pseudostate" xmi:id="_IRX60HiMEeOlpfB_tZS-QA" name="Initial0"/>
+          <subvertex xmi:type="uml:State" xmi:id="_IqdJMHiMEeOlpfB_tZS-QA" name="new"/>
+          <subvertex xmi:type="uml:State" xmi:id="_KcUvcHiMEeOlpfB_tZS-QA" name="attached"/>
+          <subvertex xmi:type="uml:State" xmi:id="_M9r48HiMEeOlpfB_tZS-QA" name="detached"/>
+        </region>
+      </packagedElement>
+    </packagedElement>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Package" xmi:id="_0oBF4EyqEeObF6ELIGKT-g" name="emf">
+    <packagedElement xmi:type="uml:Class" xmi:id="_3MwTgEyqEeObF6ELIGKT-g" name="EObject"/>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Model" xmi:id="_hGB24IeYEeOyqaF0O659SA" name="generated"/>
+  <packagedElement xmi:type="uml:Model" xmi:id="_hG5ZkIeYEeOyqaF0O659SA" name="layers">
+    <packagedElement xmi:type="uml:Package" xmi:id="_hG5ZkYeYEeOyqaF0O659SA" name="org">
+      <packagedElement xmi:type="uml:Package" xmi:id="_hG5ZkoeYEeOyqaF0O659SA" name="eclipse">
+        <packagedElement xmi:type="uml:Package" xmi:id="_hG5Zk4eYEeOyqaF0O659SA" name="papyrus">
+          <packagedElement xmi:type="uml:Package" xmi:id="_hG5ZlIeYEeOyqaF0O659SA" name="layers">
+            <packagedElement xmi:type="uml:Package" xmi:id="_hG5ZlYeYEeOyqaF0O659SA" name="stackmodel">
+              <packagedElement xmi:type="uml:Package" xmi:id="_hG5ZloeYEeOyqaF0O659SA" name="layers">
+                <packagedElement xmi:type="uml:Interface" xmi:id="_hG_gMIeYEeOyqaF0O659SA" name="LayersFactoryForStack">
+                  <ownedComment xmi:type="uml:Comment" xmi:id="_hG_gMYeYEeOyqaF0O659SA">
+                    <body>
+ * &lt;!-- begin-user-doc -->
+ * The &lt;b>Factory&lt;/b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * &lt;!-- end-user-doc -->
+ * @see org.eclipse.papyrus.layers.stackmodel.layers.LayersPackage
+ * @generated
+ </body>
+                  </ownedComment>
+                  <ownedAttribute xmi:type="uml:Property" xmi:id="_hG_gMoeYEeOyqaF0O659SA" name="eINSTANCE" type="_hG_gMIeYEeOyqaF0O659SA" isUnique="false">
+                    <ownedComment xmi:type="uml:Comment" xmi:id="_hG_gM4eYEeOyqaF0O659SA">
+                      <body>
+	 * The singleton instance of the factory.
+	 * &lt;!-- begin-user-doc -->
+	 * &lt;!-- end-user-doc -->
+	 * @generated
+	 </body>
+                    </ownedComment>
+                  </ownedAttribute>
+                  <ownedOperation xmi:type="uml:Operation" xmi:id="_hG_gNIeYEeOyqaF0O659SA" name="createLayersStack">
+                    <ownedComment xmi:type="uml:Comment" xmi:id="_hG_gNYeYEeOyqaF0O659SA">
+                      <body>
+	 * Returns a new object of class '&lt;em>Stack&lt;/em>'.
+	 * &lt;!-- begin-user-doc -->
+	 * &lt;!-- end-user-doc -->
+	 * @return a new object of class '&lt;em>Stack&lt;/em>'.
+	 * @generated
+	 </body>
+                    </ownedComment>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hG_gN4eYEeOyqaF0O659SA" type="_hG_gNoeYEeOyqaF0O659SA" direction="return"/>
+                  </ownedOperation>
+                  <ownedOperation xmi:type="uml:Operation" xmi:id="_hHFm0oeYEeOyqaF0O659SA" name="createLayer" visibility="public">
+                    <ownedComment xmi:type="uml:Comment" xmi:id="_hHFm04eYEeOyqaF0O659SA">
+                      <body>
+	 * Returns a new object of class '&lt;em>Layer&lt;/em>'.
+	 * &lt;!-- begin-user-doc -->
+	 * &lt;!-- end-user-doc -->
+	 * @return a new object of class '&lt;em>Layer&lt;/em>'.
+	 * @generated NOT
+	 </body>
+                    </ownedComment>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm1IeYEeOyqaF0O659SA" type="_uIcTcM-wEeKO_rl5MA6s9A" direction="return"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm1YeYEeOyqaF0O659SA" name="parent" type="_hHFm0IeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm1oeYEeOyqaF0O659SA" name="owningStack" type="_hG_gNoeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm14eYEeOyqaF0O659SA" name="application" type="_hHFm0YeYEeOyqaF0O659SA"/>
+                  </ownedOperation>
+                  <ownedOperation xmi:type="uml:Operation" xmi:id="_hHFm2IeYEeOyqaF0O659SA" name="createRegExpLayer" visibility="public">
+                    <ownedComment xmi:type="uml:Comment" xmi:id="_hHFm2YeYEeOyqaF0O659SA">
+                      <body>
+	 * Returns a new object of class '&lt;em>Reg Exp Layer&lt;/em>'.
+	 * &lt;!-- begin-user-doc -->
+	 * &lt;!-- end-user-doc -->
+	 * @return a new object of class '&lt;em>Reg Exp Layer&lt;/em>'.
+	 * @throws LayersException 
+	 * @generated
+	 </body>
+                    </ownedComment>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm2oeYEeOyqaF0O659SA" type="_u6-HIM-xEeKO_rl5MA6s9A" direction="return"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm24eYEeOyqaF0O659SA" name="parent" type="_hHFm0IeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm3IeYEeOyqaF0O659SA" name="owningStack" type="_hG_gNoeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm3YeYEeOyqaF0O659SA" name="application" type="_hHFm0YeYEeOyqaF0O659SA"/>
+                  </ownedOperation>
+                  <ownedOperation xmi:type="uml:Operation" xmi:id="_hHFm3oeYEeOyqaF0O659SA" name="createTopLayerOperator" visibility="public">
+                    <ownedComment xmi:type="uml:Comment" xmi:id="_hHFm34eYEeOyqaF0O659SA">
+                      <body>
+	 * Returns a new object of class '&lt;em>Top Layer Operator&lt;/em>'.
+	 * &lt;!-- begin-user-doc -->
+	 * &lt;!-- end-user-doc -->
+	 * @return a new object of class '&lt;em>Top Layer Operator&lt;/em>'.
+	 * @generated
+	 </body>
+                    </ownedComment>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm4YeYEeOyqaF0O659SA" type="_hHFm4IeYEeOyqaF0O659SA" direction="return"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm4oeYEeOyqaF0O659SA" name="parent" type="_hHFm0IeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm44eYEeOyqaF0O659SA" name="owningStack" type="_hG_gNoeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm5IeYEeOyqaF0O659SA" name="application" type="_hHFm0YeYEeOyqaF0O659SA"/>
+                  </ownedOperation>
+                  <ownedOperation xmi:type="uml:Operation" xmi:id="_hHFm5YeYEeOyqaF0O659SA" name="createStackedLayerOperator" visibility="public">
+                    <ownedComment xmi:type="uml:Comment" xmi:id="_hHFm5oeYEeOyqaF0O659SA">
+                      <body>
+	 * Returns a new object of class '&lt;em>Stacked Layer Operator&lt;/em>'.
+	 * &lt;!-- begin-user-doc -->
+	 * &lt;!-- end-user-doc -->
+	 * @return a new object of class '&lt;em>Stacked Layer Operator&lt;/em>'.
+	 * @generated
+	 </body>
+                    </ownedComment>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm6IeYEeOyqaF0O659SA" type="_hHFm54eYEeOyqaF0O659SA" direction="return"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm6YeYEeOyqaF0O659SA" name="parent" type="_hHFm0IeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm6oeYEeOyqaF0O659SA" name="owningStack" type="_hG_gNoeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm64eYEeOyqaF0O659SA" name="application" type="_hHFm0YeYEeOyqaF0O659SA"/>
+                  </ownedOperation>
+                  <ownedOperation xmi:type="uml:Operation" xmi:id="_hHFm7IeYEeOyqaF0O659SA" name="initLayer" visibility="public">
+                    <ownedComment xmi:type="uml:Comment" xmi:id="_hHFm7YeYEeOyqaF0O659SA">
+                      <body>
+	 * Standard initialization of a newly created layer.
+	 * 
+	 * @param layer
+	 * @param parentLayer
+	 * @param owningStack
+	 * @param application
+	 * @return
+	 * @throws LayersException
+	 </body>
+                    </ownedComment>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm7oeYEeOyqaF0O659SA" type="_q3GegM-wEeKO_rl5MA6s9A" direction="return"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm74eYEeOyqaF0O659SA" name="layer" type="_q3GegM-wEeKO_rl5MA6s9A"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm8IeYEeOyqaF0O659SA" name="parentLayer" type="_hHFm0IeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm8YeYEeOyqaF0O659SA" name="owningStack" type="_hG_gNoeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHFm8oeYEeOyqaF0O659SA" name="application" type="_hHFm0YeYEeOyqaF0O659SA"/>
+                  </ownedOperation>
+                  <ownedOperation xmi:type="uml:Operation" xmi:id="_hHFm94eYEeOyqaF0O659SA" name="createLayerOperator" visibility="public">
+                    <ownedComment xmi:type="uml:Comment" xmi:id="_hHLtcIeYEeOyqaF0O659SA">
+                      <body>
+	 * Create a LayerOperator by its ID. 
+	 * IDs are those used when the LayerOperator is registered in application'registry.
+	 * 
+	 * @param layerOperatorID
+	 * @param parent
+	 * @param owningStack
+	 * @param application
+	 * @return
+	 * @throws LayersException
+	 </body>
+                    </ownedComment>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHLtcoeYEeOyqaF0O659SA" type="_hHLtcYeYEeOyqaF0O659SA" direction="return"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHLtc4eYEeOyqaF0O659SA" name="layerOperatorID" type="_hHFm9oeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHLtdIeYEeOyqaF0O659SA" name="parent" type="_hHFm0IeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHLtdYeYEeOyqaF0O659SA" name="owningStack" type="_hG_gNoeYEeOyqaF0O659SA"/>
+                    <ownedParameter xmi:type="uml:Parameter" xmi:id="_hHLtdoeYEeOyqaF0O659SA" name="application" type="_hHFm0YeYEeOyqaF0O659SA"/>
+                  </ownedOperation>
+                </packagedElement>
+                <packagedElement xmi:type="uml:Class" xmi:id="_hG_gNoeYEeOyqaF0O659SA" name="LayersStack"/>
+                <packagedElement xmi:type="uml:Class" xmi:id="_hHFm0IeYEeOyqaF0O659SA" name="LayersContainer"/>
+                <packagedElement xmi:type="uml:Class" xmi:id="_hHFm0YeYEeOyqaF0O659SA" name="LayersStackApplication"/>
+                <packagedElement xmi:type="uml:Class" xmi:id="_hHFm4IeYEeOyqaF0O659SA" name="TopLayerOperator"/>
+                <packagedElement xmi:type="uml:Class" xmi:id="_hHFm54eYEeOyqaF0O659SA" name="StackedLayerOperator"/>
+                <packagedElement xmi:type="uml:Class" xmi:id="_hHLtcYeYEeOyqaF0O659SA" name="AbstractLayerOperator"/>
+              </packagedElement>
+            </packagedElement>
+          </packagedElement>
+        </packagedElement>
+      </packagedElement>
+    </packagedElement>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Model" xmi:id="_hHFm84eYEeOyqaF0O659SA" name="java">
+    <packagedElement xmi:type="uml:Package" xmi:id="_hHFm9IeYEeOyqaF0O659SA" name="java">
+      <packagedElement xmi:type="uml:Package" xmi:id="_hHFm9YeYEeOyqaF0O659SA" name="lang">
+        <packagedElement xmi:type="uml:Class" xmi:id="_hHFm9oeYEeOyqaF0O659SA" name="String"/>
+      </packagedElement>
+    </packagedElement>
+  </packagedElement>
+</uml:Model>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/plugin.properties b/layers/plugins/org.eclipse.papyrus.layers.documentation/plugin.properties
new file mode 100755
index 0000000..d95844c
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/plugin.properties
@@ -0,0 +1,12 @@
+#################################################################################
+# Copyright (c) 2013 CEA LIST.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     Cedric Dumoulin  Cedric.dumoulin@lifl.fr - Initial API and implementation
+##################################################################################
+pluginName=Papyrus Layers Documentation 
+providerName=Eclipse Modeling Project
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/plugin.xml b/layers/plugins/org.eclipse.papyrus.layers.documentation/plugin.xml
new file mode 100755
index 0000000..be68dac
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/plugin.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension
+         point="org.eclipse.help.toc">
+      <toc
+            file="target/generated-eclipse-help/guides/users/index-toc.xml"
+            primary="false">
+      </toc>
+      <toc
+            file="target/generated-eclipse-help/guides/tutorials/layers-toc.xml"
+            primary="false">
+      </toc>
+      <toc
+            file="target/generated-eclipse-help/guides/tutorials/simpleTutorial-toc.xml"
+            primary="false">
+      </toc>
+      <toc
+            file="target/generated-eclipse-help/guides/tutorials/derivedLayerTutorial-toc.xml"
+            primary="false">
+      </toc>
+      <toc
+            file="target/generated-eclipse-help/guides/developpers/layers-toc.xml"
+            primary="false">
+      </toc>
+      <toc
+            file="target/generated-eclipse-help/guides/developpers/layersDevs-toc.xml"
+            primary="false">
+      </toc>
+      <toc
+            file="target/generated-eclipse-help/guides/index-toc.xml"
+            primary="false">
+      </toc>
+   </extension>
+
+</plugin>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/pom.xml b/layers/plugins/org.eclipse.papyrus.layers.documentation/pom.xml
new file mode 100755
index 0000000..eda76fb
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/pom.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.plugins-doc</artifactId>
+		<groupId>org.eclipse.papyrus</groupId>
+		<version>0.0.1-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.layers.documentation</artifactId>
+	<version>1.2.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.eclipse.mylyn.docs</groupId>
+				<artifactId>org.eclipse.mylyn.wikitext.core.maven</artifactId>
+				<configuration>
+					<sourceFolder>resources</sourceFolder>
+					<outputFolder>${project.build.directory}/generated-eclipse-help</outputFolder>
+					<!-- copyrightNotice>${help.copyrightNotice}</copyrightNotice> <title>${help.documentTitle}</title -->
+					<multipleOutputFiles>false</multipleOutputFiles>
+					<navigationImages>true</navigationImages>
+					<formatOutput>true</formatOutput>
+					<htmlFilenameFormat>$1.html</htmlFilenameFormat>
+					<xmlFilenameFormat>$1-toc.xml</xmlFilenameFormat>
+					<helpPrefix>target/generated-eclipse-help</helpPrefix>
+					<!-- stylesheetUrls> <param>styles/main.css</param> </stylesheetUrls -->
+				</configuration>
+				<executions>
+					<execution>
+						<goals>
+							<goal>eclipse-help</goal>
+						</goals>
+					</execution>
+				</executions>
+				<dependencies>
+					<dependency>
+						<groupId>org.eclipse.mylyn.docs</groupId>
+						<artifactId>org.eclipse.mylyn.wikitext.mediawiki.core</artifactId>
+						<version>${mylyn.wikitext.version}</version>
+					</dependency>
+				</dependencies>
+			</plugin>
+		</plugins>
+	</build>
+	<name>Papyrus Layers doc</name>
+</project>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/developpers/layers-toc.xml b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/developpers/layers-toc.xml
new file mode 100755
index 0000000..8392350
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/developpers/layers-toc.xml
@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<toc label="Papyrus Layers" link_to="../org.eclipse.papyrus.infra.doc/toc.xml#PapyrusDocDev">
+	<topic href="target/generated-eclipse-help/guides/developpers/layersDevs.html" label="Layers Developers Documentation">
+        <link toc="target/generated-eclipse-help/guides/developpers/layersDevs-toc.xml"/>
+        <anchor id="layers.guides.devs"/>
+	</topic>
+</toc>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/developpers/layersDevs.mediawiki b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/developpers/layersDevs.mediawiki
new file mode 100755
index 0000000..bc32fe5
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/developpers/layersDevs.mediawiki
@@ -0,0 +1,8 @@
+== Layers Developpers ==
+This is the documentation for layers developpers
+
+
+== General Architecture ==
+
+== Plugins ==
+
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/index-toc.xml b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/index-toc.xml
new file mode 100755
index 0000000..76d2cea
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/index-toc.xml
@@ -0,0 +1,9 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<toc label="Using Layers" link_to="../org.eclipse.papyrus.infra.doc/toc.xml#PapyrusTasks">
+  <topic label="Using Layers" >
+     <link toc="target/generated-eclipse-help/guides/tutorials/layers-toc.xml"/>
+     <anchor id="tutorials"/>
+     <link toc="target/generated-eclipse-help/guides/users/index-toc.xml"/>
+     <anchor id="documentation"/>
+  </topic>
+</toc>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial.mediawiki b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial.mediawiki
new file mode 100755
index 0000000..583466e
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial.mediawiki
@@ -0,0 +1,70 @@
+= Using Derived Layer (OCL Expression) =
+
+This tutorial show how to use a Derived Layer.
+
+A derived layer is a leaf Layer where the views are automatically attached to 
+the layer, according to an expression. Actually, the expression is expressed in OCL.
+
+== Tutorial Video ==
+
+A tutorial is available here:
+[http://youtu.be/x6lnWwD47ZI] 
+
+== Creating a derived Layer ==
+Derived Layer are actually called 'RegExp Layer'.
+
+To create a derived layer:
+
+* Click on the Layer stack
+* Click Layer->Create Layers ...->Create RegExp Layer
+
+
+[[Image:derivedLayerTutorial/createRegExpLayer.png]]
+
+The new Layer appears under the Layer Stack. You can add Properties to the layer.
+
+== Writing an expression == 
+A derived layer is a Layer where views are automatically attached to 
+the layer. The expression is used for this purpose.
+
+Actually, the expression can only be written in OCL.
+
+The expression is a boolean expression returning true or false. The expression is applied on each '''''view''''' (ie Shapes and Links) in the diagram. If the expression return true, the corresponding element is attached to the layer. If the expression return false, the element is not attached to the layer.
+
+The OCL expression has a predefined variable called 'self'. It is the 'view' that must be checked.
+This variable is of type '''''notation::View''''' . It can be subclassed in '''''notation::Shape'''''  and '''''notation::Link''''' .
+
+A view in a uml diagram is always associated to a UML element. This element can be accessed with the expression '''''self.element''''' .
+
+The expression is written in the Layer property->Expr
+[[Image:derivedLayerTutorial/writeExpression.png]]
+
+
+== Expressions Examples == 
+
+=== All Shapes  ===
+* self.oclIsKindOf(Shape)
+
+=== All Classes/Interface/ ...  ===
+* self.element.oclIsKindOf(uml::NamedElement)
+* self.element.oclIsKindOf(uml::Class)
+* self.element.oclIsKindOf(uml::Package)
+
+=== All Classes/NamedElement/... starting with a particular string ===
+* self.element.oclAsType(uml::NamedElement).name.startsWith('D') = true
+* self.element.oclAsType(uml::Class).name.startsWith('Cl') = true
+* self.element.oclAsType(uml::Interface).name.startsWith('I') = true
+
+=== and / or ===
+* self.oclIsKindOf(Shape) '''and'''  self.oclAsType(Shape).visible = true 
+
+* self.element.oclIsKindOf(uml::Class) '''or'''  self.element.oclIsKindOf(uml::Package) 
+=== All classes that are abstract ===
+* self.element.oclAsType(uml::Class).isAbstract
+
+=== All classes containing an operation named 'op1' ===
+* self.element.oclAsType(uml::Class).ownedOperation->exists( op | op.name = 'op1')
+
+Also:
+* self.element.oclAsType(uml::Class).ownedAttribute->exists( attr | attr.name = 'name')
+
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial/createRegExpLayer.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial/createRegExpLayer.png
new file mode 100755
index 0000000..e277553
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial/createRegExpLayer.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial/writeExpression.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial/writeExpression.png
new file mode 100755
index 0000000..81061e0
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/derivedLayerTutorial/writeExpression.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/layers-toc.xml b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/layers-toc.xml
new file mode 100755
index 0000000..d19a857
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/layers-toc.xml
@@ -0,0 +1,8 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<toc label="Layers Tutorials" >
+	<topic label="Layers Tutorials">
+        <link toc="target/generated-eclipse-help/guides/tutorials/simpleTutorial-toc.xml"/>
+        <link toc="target/generated-eclipse-help/guides/tutorials/derivedLayerTutorial-toc.xml"/>
+        <anchor id="layers.guides.tutorials"/>
+	</topic>
+</toc>
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorial.mediawiki b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorial.mediawiki
new file mode 100755
index 0000000..c4289c4
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorial.mediawiki
@@ -0,0 +1,136 @@
+
+
+= A simple Example and Tutorial =
+In this example, we create a class diagram with 3 classes (class1, class2, class3), and a LayersStack with 3 layers (layer2, layer1, bottom). The bottom layer control the 3 classes and all the available properties. The layer1 control Class1 and Class2. The layer2 control Class2 and Class3.
+
+This example is also a tutorial, if you follow it step by step.
+
+== Create a new Class Diagram ==
+Start by creating a Papyrus Class Diagram with 3 classes:
+* Create a new ClassDiagram in a Papyrus model
+* Create three classes: Class1, Class2, Class3
+* Open the Papyrus ModelExplorer and the Property View.
+You should have a diagram and model explorer like in the following figure:
+
+[[Image:simpleTutorialImages/diagramWith3Classes.png]]
+
+== Open the LayersExplorer ==
+To open the LayersExplorer:
+* In the diagram, Right Click->Layers->Open LayersExplorer
+[[Image:simpleTutorialImages/opnLayersExplorer.png]]
+
+* The explorer should open (not necessarly at the same position as in the following snapshoot):
+[[Image:simpleTutorialImages/OpenedLayersExplorer.png]]
+
+
+== Attach a LayersStack to your diagram ==
+To attach a LayersStack to your diagram:
+
+* Click in the diagram, then Right Click->Layers->Attach Layer Stack
+[[Image:simpleTutorialImages/attachLayersStack.png]]
+
+* The LayersExplorer should show the layers attached to the LayersStack. By default, there is a 'Layer Operator' of type 'Top Layer'. The 'Top Layer Operator' contains layers that are ordered from top to bottom. When computing the value for a particular (view, property type) couple, it search the first layer that define a value for the couple, and return this value.
+
+[[Image:simpleTutorialImages/attachedLayersStack.png]]
+
+== Create a new Layer in the LayersStack ==
+We need now to create a layer in the stack.
+
+To create a new Layer in the LayersStack:
+
+* In the LayerExplorer, select the Top Layer Operator
+* right click->Layers->Create Layers ...->Create Layer
+[[Image:simpleTutorialImages/createLayer.png]]
+
+* A new layer is created:
+** Open the tree node to see the layer (1)
+** Select the layers tab in the Property view (2)
+** Change the name of the layer to 'bottomLayer' (3)
+[[Image:simpleTutorialImages/createdLayer.png]]
+
+
+== Attach Classes to the Layer ==
+
+Attaching some classes (also called views) to a layer means that this layer will partially control the value of some properties for this attached classes.
+Here, we attach the 3 classes.
+To Attach the classes to the Layer:
+* Select the layer 'bottomLayer', right click->Layers->Attach Views
+[[Image:simpleTutorialImages/attachViewsToLayer.png]] 
+
+* A window open, select the 3 classes (1) and click 'ok (2)'.:
+[[Image:simpleTutorialImages/attachViewWindowSelectClasses.png]]
+
+== Attach some properties to the layer ==
+
+A layer is used to control some properties of the attached views. It is necessary to attach the properties
+controled by the layer. Once attached, it is possible to modify the values of this properties.
+
+To attach some properties to the layer:
+* In the LayersExplorer, select the defaul layer, right click->Layers->Attach Properties
+[[Image:simpleTutorialImages/openAttachPropertiesWindow.png]]
+
+* The Attach Properties window open. Select properties as in the screenshot, and then 'ok'.
+[[Image:simpleTutorialImages/attachPropertiesWindow.png]]
+
+* The properties and the views are now attached to the layers. Properties for these views are computed according to the layer, and as a resul the fill color change. This is because the default value for 'fill color' of the layer property is different from the Papyrus value.
+** You can open the property node in the LayersExplorer, select a property, and change its value in the Property view.
+[[Image:simpleTutorialImages/defaulLayerProperties.png]]
+
+
+
+== Add more layers ==
+Now, add a new Layer in the Top Layer Operator:
+* Select the Top Layer Operator, 
+* right click->Layers->Create Layers ...->Create Layer
+* The new layer shoul appear as the first layer of the top layer operator.
+* Attach the class1 and class2
+* Attach the fill property
+
+== Change the value of an attached property ==
+You can change the value of the fill property color for the layer.
+
+* Open the node 'Color' of the 'Fill Property' 
+* click on the color picker in the Property view. 
+* Choose a new color (blue).
+* The color should be applied on the 2 classes attached to the layer (Class1 and Class2). 
+* Class3 still have the color of the 'bottom' layer.
+[[Image:simpleTutorialImages/changeFillColorValue.png]]
+
+
+* Note that Class1 and Class2 color change to 'blue' because when computing the color for Class1, the first layer that attach both Class1and Property Fill is the Layer1. In this layer, the value for the Property Fill is 'blue', so it is for Class1. The same happen for class2.
+
+== Add the 3rd layer ==
+* Add a 3rd layer
+** Attach the 2 classes Class2 and Class3 to this layer.
+** Attach the property 'Fill Color'
+** Change the value of 'Fill Color' to orange
+*** Class2 and Class3 should change to orange.
+[[Image:simpleTutorialImages/layer2.png]]
+
+
+== Disabling a Layer ==
+It is possible to disable a layer without deleting it. A disabled layer do not participate in layer stack.
+
+To disable a layer, select it in the LayersExplorer.
+* Then in the PropertyView, open the Layers tab
+* select or unselect the layer with 'Is Layer Enable".
+** Note that in our example, disabling the Layer2 will change the color of the Class2 and Class3. Class2 take the color specified by layer1, and Class3 the color specified by bottomLayer.
+[[Image:simpleTutorialImages/disableLayer.png]]
+
+
+= Layer Operators =
+Layer Operators are a kind of layer that can contain other Layers.
+
+A layer operator is called like this because it is used to apply an 'operator' on its nested layers. The operator compute the property values for attached layers.
+
+
+It is not possible to attach directly views or properties to a layer operator. But a layer operator still have a set of attached views and a set of attached properties. The values of these properties are the results of applying the operator on the properties of the nested layers. The set of the attached views is generally the union of the views attached to the nested layers.
+
+There is different kind of 'layer operators', each one proposing a different way of computing the property values.
+
+
+== Top Layer Operator ==
+The 'Top Layer Operator' contains layers that are ordered from top to bottom. It is called 'Top Layer Operator' because it return the top most value for a particular (view, property type) couple. 
+
+When computing the property value for a specified (view, property type), the Top Layer Operator return the first value found for this couple. It start from the top layer, and stop as soon as a layer as a value set for the specified (view, property type).
+
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/OpenedLayersExplorer.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/OpenedLayersExplorer.png
new file mode 100755
index 0000000..3243d6a
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/OpenedLayersExplorer.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachLayersStack.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachLayersStack.png
new file mode 100755
index 0000000..fb89859
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachLayersStack.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachPropertiesWindow.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachPropertiesWindow.png
new file mode 100755
index 0000000..43352b5
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachPropertiesWindow.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewWindow.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewWindow.png
new file mode 100755
index 0000000..9aad29f
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewWindow.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewWindowSelectClasses.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewWindowSelectClasses.png
new file mode 100755
index 0000000..3275da0
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewWindowSelectClasses.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewsToLayer.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewsToLayer.png
new file mode 100755
index 0000000..669be6f
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachViewsToLayer.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachedLayersStack.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachedLayersStack.png
new file mode 100755
index 0000000..8d536ad
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/attachedLayersStack.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/changeFillColorValue.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/changeFillColorValue.png
new file mode 100755
index 0000000..db065e6
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/changeFillColorValue.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/createLayer.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/createLayer.png
new file mode 100755
index 0000000..190ec7c
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/createLayer.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/createdLayer.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/createdLayer.png
new file mode 100755
index 0000000..27564e6
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/createdLayer.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/defaulLayerProperties.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/defaulLayerProperties.png
new file mode 100755
index 0000000..e2da266
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/defaulLayerProperties.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/diagramWith3Classes.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/diagramWith3Classes.png
new file mode 100755
index 0000000..45529bd
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/diagramWith3Classes.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/disableLayer.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/disableLayer.png
new file mode 100755
index 0000000..f4cb2f3
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/disableLayer.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/layer2.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/layer2.png
new file mode 100755
index 0000000..9181d27
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/layer2.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/openAttachPropertiesWindow.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/openAttachPropertiesWindow.png
new file mode 100755
index 0000000..79c2737
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/openAttachPropertiesWindow.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/opnLayersExplorer.png b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/opnLayersExplorer.png
new file mode 100755
index 0000000..4a4a2c9
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/tutorials/simpleTutorialImages/opnLayersExplorer.png
Binary files differ
diff --git a/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/users/index-toc.xml b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/users/index-toc.xml
new file mode 100755
index 0000000..0e395c2
--- /dev/null
+++ b/layers/plugins/org.eclipse.papyrus.layers.documentation/resources/guides/users/index-toc.xml
@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<toc label="Layers Documentation" >
+	<topic label="Layers Documentation">
+        <link toc="target/generated-eclipse-help/guides/²tutorials/derivedLayerTutorial-toc.xml"/>
+         <anchor id="layers.guides.documentations"/>
+	</topic>
+</toc>
