3.10.2 Operations of Access Types

1
[The attribute Access is used to create access values designating aliased objects and non−intrinsic subprograms. The "accessibility" rules prevent dangling references (in the absence of uses of certain unchecked features −− see Section 13).]

1.a

It should be possible for an access value to designate an object declared by an object declaration, or a subcomponent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Access ent thereof. In implementation terms, this means pointing at stack−allocated and statically allocated data structures. However, dangling references should be prevented, primarily via compile−time rules, so long as features like Unchecked_Acces