From 21f1fb39b5e1187ef87387f20522e60abe4f7c19 Mon Sep 17 00:00:00 2001
From: Claudio Sacerdoti Coen <claudio.sacerdoticoen@unibo.it>
Date: Wed, 16 Jul 2008 12:37:24 +0000
Subject: [PATCH] a) update with upstream version b) new: implemented semantic
 analyzer from untyped to typed AST for    an imperative structured
 function-less C compiler c) all URIs removed from .ma files

---
 .../contribs/assembly/compiler/ast_tree.ma    |  130 ++
 .../contribs/assembly/compiler/ast_type.ma    |  112 ++
 .../contribs/assembly/compiler/environment.ma |  114 ++
 .../assembly/compiler/preast_to_ast.ma        |  480 ++++++
 .../contribs/assembly/compiler/preast_tree.ma |   92 ++
 .../contribs/assembly/compiler/utility.ma     |  204 +++
 .../software/matita/contribs/assembly/depends |   47 +-
 .../assembly/freescale/Doc/counting_sort.txt  |  613 ++++++++
 .../assembly/freescale/Doc/daa_test.txt       | 1334 +++++++++++++++++
 .../freescale/Doc/numeri_perfetti.txt         |  302 ++++
 .../freescale/Doc/ordine_compilazione.txt     |   32 +
 .../assembly/freescale/Doc/string_reverse.txt |   99 ++
 .../contribs/assembly/freescale/aux_bases.ma  |    4 +-
 .../contribs/assembly/freescale/byte8.ma      |    2 +-
 .../contribs/assembly/freescale/exadecim.ma   |    2 +-
 .../contribs/assembly/freescale/load_write.ma |  122 +-
 .../contribs/assembly/freescale/model.ma      |    8 +-
 .../contribs/assembly/freescale/multivm.ma    |   62 +-
 .../contribs/assembly/freescale/opcode.ma     |    6 +-
 .../assembly/freescale/translation.ma         |    4 +-
 .../contribs/assembly/freescale/word16.ma     |    2 +-
 .../contribs/assembly/freescale/word32.ma     |  224 +++
 .../contribs/assembly/string/ascii_min.ma     |  177 +++
 .../matita/contribs/assembly/string/string.ma |   56 +
 24 files changed, 4103 insertions(+), 125 deletions(-)
 create mode 100755 helm/software/matita/contribs/assembly/compiler/ast_tree.ma
 create mode 100755 helm/software/matita/contribs/assembly/compiler/ast_type.ma
 create mode 100755 helm/software/matita/contribs/assembly/compiler/environment.ma
 create mode 100755 helm/software/matita/contribs/assembly/compiler/preast_to_ast.ma
 create mode 100755 helm/software/matita/contribs/assembly/compiler/preast_tree.ma
 create mode 100755 helm/software/matita/contribs/assembly/compiler/utility.ma
 create mode 100755 helm/software/matita/contribs/assembly/freescale/Doc/counting_sort.txt
 create mode 100755 helm/software/matita/contribs/assembly/freescale/Doc/daa_test.txt
 create mode 100755 helm/software/matita/contribs/assembly/freescale/Doc/numeri_perfetti.txt
 create mode 100755 helm/software/matita/contribs/assembly/freescale/Doc/ordine_compilazione.txt
 create mode 100755 helm/software/matita/contribs/assembly/freescale/Doc/string_reverse.txt
 create mode 100755 helm/software/matita/contribs/assembly/freescale/word32.ma
 create mode 100755 helm/software/matita/contribs/assembly/string/ascii_min.ma
 create mode 100755 helm/software/matita/contribs/assembly/string/string.ma

diff --git a/helm/software/matita/contribs/assembly/compiler/ast_tree.ma b/helm/software/matita/contribs/assembly/compiler/ast_tree.ma
new file mode 100755
index 000000000..381ea92fb
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/compiler/ast_tree.ma
@@ -0,0 +1,130 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "compiler/environment.ma".
+
+(* *************** *)
+(* ALBERO DI TOKEN *)
+(* *************** *)
+
+(* id: accesso all'ambiente con stringa *)
+inductive ast_id (e:aux_env_type) : bool → ast_type → Type ≝
+  AST_ID: ∀str:aux_str_type.
+          (* D *) check_desc_env e str → ast_id e (get_const_desc (get_desc_env e str)) (get_type_desc (get_desc_env e str)).
+
+(* -------------------------- *)
+
+(* espressioni *)
+inductive ast_expr (e:aux_env_type) : ast_base_type → Type ≝
+  AST_EXPR_BYTE8 : byte8 → ast_expr e AST_BASE_TYPE_BYTE8
+| AST_EXPR_WORD16: word16 → ast_expr e AST_BASE_TYPE_WORD16
+| AST_EXPR_WORD32: word32 → ast_expr e AST_BASE_TYPE_WORD32
+
+| AST_EXPR_NEG: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t
+| AST_EXPR_NOT: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t
+| AST_EXPR_COM: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t
+
+| AST_EXPR_ADD: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e t
+| AST_EXPR_SUB: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e t
+| AST_EXPR_MUL: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e t
+| AST_EXPR_DIV: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e t
+| AST_EXPR_SHR: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e AST_BASE_TYPE_BYTE8 → ast_expr e t
+| AST_EXPR_SHL: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e AST_BASE_TYPE_BYTE8 → ast_expr e t
+
+| AST_EXPR_GT : ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e AST_BASE_TYPE_BYTE8
+| AST_EXPR_GTE: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e AST_BASE_TYPE_BYTE8
+| AST_EXPR_LT : ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e AST_BASE_TYPE_BYTE8
+| AST_EXPR_LTE: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e AST_BASE_TYPE_BYTE8
+| AST_EXPR_EQ : ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e AST_BASE_TYPE_BYTE8
+| AST_EXPR_NEQ: ∀t:ast_base_type.
+                ast_expr e t → ast_expr e t → ast_expr e AST_BASE_TYPE_BYTE8
+
+| AST_EXPR_B8toW16 : ast_expr e AST_BASE_TYPE_BYTE8 → ast_expr e AST_BASE_TYPE_WORD16
+| AST_EXPR_B8toW32 : ast_expr e AST_BASE_TYPE_BYTE8 → ast_expr e AST_BASE_TYPE_WORD32
+| AST_EXPR_W16toB8 : ast_expr e AST_BASE_TYPE_WORD16 → ast_expr e AST_BASE_TYPE_BYTE8
+| AST_EXPR_W16toW32: ast_expr e AST_BASE_TYPE_WORD16 → ast_expr e AST_BASE_TYPE_WORD32
+| AST_EXPR_W32toB8 : ast_expr e AST_BASE_TYPE_WORD32 → ast_expr e AST_BASE_TYPE_BYTE8
+| AST_EXPR_W32toW16: ast_expr e AST_BASE_TYPE_WORD32 → ast_expr e AST_BASE_TYPE_WORD16
+
+| AST_EXPR_ID: ∀b:bool.∀t:ast_base_type.
+               ast_var e b (AST_TYPE_BASE t) → ast_expr e t
+
+(* espressioni generalizzate: anche non uniformi per tipo *)
+with ast_base_expr : Type ≝
+  AST_BASE_EXPR: ∀t:ast_base_type.
+                 ast_expr e t → ast_base_expr e
+
+(* variabile: modificatori di array/struct dell'id *)
+with ast_var : bool → ast_type → Type ≝
+  AST_VAR_ID: ∀b:bool.∀t:ast_type.
+              ast_id e b t → ast_var e b t
+                 (* NB: l'index out of bound e' delegato a runtime? *)
+| AST_VAR_ARRAY: ∀b:bool.∀t:ast_type.∀n:nat.
+                 ast_var e b (AST_TYPE_ARRAY t n) → ast_base_expr e → ast_var e b t
+| AST_VAR_STRUCT: ∀b:bool.∀nel:ne_list ast_type.∀n:nat.
+                  ast_var e b (AST_TYPE_STRUCT nel) → (* D *) (ltb n (len_neList ? nel) = true) → ast_var e b (abs_nth_neList ? nel n).
+
+(* -------------------------- *)
+
+(* statement: assegnamento/while/if else if else *)
+inductive ast_stm : aux_env_type → Type ≝
+  AST_STM_ASG: ∀e:aux_env_type.∀t:ast_base_type.
+               ast_var e false (AST_TYPE_BASE t) → ast_expr e t → ast_stm e
+| AST_STM_MEMCPY_ASG: ∀e:aux_env_type.∀b:bool.∀t:ast_type.
+                      (* D *) isnt_ast_base_type t → ast_var e false t → ast_var e b t → ast_stm e
+| AST_STM_WHILE: ∀e:aux_env_type.
+                 ast_base_expr e → ast_decl e → ast_stm e
+| AST_STM_IF: ∀e:aux_env_type.
+              ne_list (Prod (ast_base_expr e) (ast_decl e)) → option (ast_decl e) → ast_stm e
+
+(* dichiarazioni *)
+with ast_decl : aux_env_type → Type ≝
+  AST_NO_DECL: ∀e:aux_env_type.
+               list (ast_stm e) → ast_decl e
+| AST_BASE_DECL: ∀e:aux_env_type.∀c:bool.∀str:aux_str_type.∀t:ast_base_type.
+                 (* D *) (check_not_already_def_env e str) → option (ast_expr e t) → ast_decl (add_desc_env e str c (AST_TYPE_BASE t)) → ast_decl e
+| AST_DECL: ∀e:aux_env_type.∀c:bool.∀str:aux_str_type.∀t:ast_type.
+            (* D *) (check_not_already_def_env e str) → (* D *) isnt_ast_base_type t → ast_decl (add_desc_env e str c t) → ast_decl e.
+
+(* -------------------------- *)
+
+(* programma *)
+inductive ast_root : Type ≝
+  AST_ROOT: ast_decl empty_env → ast_root.
+
+(* -------------------------- *)
+
+(* programma vuoto *)
+definition empty_ast_prog ≝ AST_ROOT (AST_NO_DECL empty_env (nil ?)).
diff --git a/helm/software/matita/contribs/assembly/compiler/ast_type.ma b/helm/software/matita/contribs/assembly/compiler/ast_type.ma
new file mode 100755
index 000000000..5939fe4f4
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/compiler/ast_type.ma
@@ -0,0 +1,112 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "compiler/utility.ma".
+include "freescale/word32.ma".
+
+(* ************************* *)
+(* dimensioni degli elementi *)
+(* ************************* *)
+
+(* usato per definire nell'ast *)
+inductive ast_base_type : Type ≝
+  AST_BASE_TYPE_BYTE8: ast_base_type
+| AST_BASE_TYPE_WORD16: ast_base_type
+| AST_BASE_TYPE_WORD32: ast_base_type.
+
+inductive ast_type : Type ≝
+  AST_TYPE_BASE: ast_base_type → ast_type
+| AST_TYPE_ARRAY: ast_type → nat → ast_type
+| AST_TYPE_STRUCT: ne_list ast_type → ast_type.
+
+definition eq_ast_base_type ≝
+λt1,t2:ast_base_type.match t1 with
+ [ AST_BASE_TYPE_BYTE8 ⇒ match t2 with
+  [ AST_BASE_TYPE_BYTE8 ⇒ true | _ ⇒ false ]
+ | AST_BASE_TYPE_WORD16 ⇒ match t2 with
+  [ AST_BASE_TYPE_WORD16 ⇒ true | _ ⇒ false ]
+ | AST_BASE_TYPE_WORD32 ⇒ match t2 with
+  [ AST_BASE_TYPE_WORD32 ⇒ true | _ ⇒ false ]
+ ].
+
+let rec eq_ast_type (t1,t2:ast_type) on t1 ≝
+ match t1 with
+  [ AST_TYPE_BASE bType1 ⇒ match t2 with
+   [ AST_TYPE_BASE bType2 ⇒ eq_ast_base_type bType1 bType2 | _ ⇒ false ]
+  | AST_TYPE_ARRAY subType1 dim1 ⇒ match t2 with
+   [ AST_TYPE_ARRAY subType2 dim2 ⇒ (eq_ast_type subType1 subType2) ⊗ (eqb dim1 dim2) | _ ⇒ false ]
+  | AST_TYPE_STRUCT nelSubType1 ⇒ match t2 with
+   [ AST_TYPE_STRUCT nelSubType2 ⇒ 
+    fst ?? (fold_right_neList ?? (λh,t.match fst ?? t with
+                                       [ true ⇒ match nth_neList ? nelSubType2 ((len_neList ? nelSubType2)-(snd ?? t)-1) with
+                                        [ None ⇒ pair ?? false (S (snd ?? t))
+                                        | Some cfr ⇒ match eq_ast_type h cfr with
+                                         [ true ⇒ pair ?? true (S (snd ?? t))
+                                         | false ⇒ pair ?? false (S (snd ?? t)) ]]
+                                       | false ⇒ t]) (pair ?? true O) nelSubType1)
+   | _ ⇒ false ]
+  ].
+
+definition is_ast_base_type ≝
+λast:ast_type.match ast with [ AST_TYPE_BASE _ ⇒ True | _ ⇒ False ].
+
+definition isb_ast_base_type ≝
+λast:ast_type.match ast with [ AST_TYPE_BASE _ ⇒ true | _ ⇒ false ].
+
+lemma isbastbasetype_to_isastbasetype : ∀ast.isb_ast_base_type ast = true → is_ast_base_type ast.
+ unfold isb_ast_base_type;
+ unfold is_ast_base_type;
+ intros;
+ elim ast;
+ [ normalize; autobatch |
+   normalize; autobatch |
+   normalize; autobatch ]
+qed.
+
+definition isnt_ast_base_type ≝
+λast:ast_type.match ast with [ AST_TYPE_BASE _ ⇒ False | _ ⇒ True ].
+
+definition isntb_ast_base_type ≝
+λast:ast_type.match ast with [ AST_TYPE_BASE _ ⇒ false | _ ⇒ true ].
+
+lemma isntbastbasetype_to_isntastbasetype : ∀ast.isntb_ast_base_type ast = true → isnt_ast_base_type ast.
+ unfold isntb_ast_base_type;
+ unfold isnt_ast_base_type;
+ intros;
+ elim ast;
+ [ normalize; autobatch |
+   normalize; autobatch |
+   normalize; autobatch ]
+qed.
+
+definition eval_size_base_type ≝
+λast:ast_base_type.match ast with
+ [ AST_BASE_TYPE_BYTE8 ⇒ 1
+ | AST_BASE_TYPE_WORD16 ⇒ 2
+ | AST_BASE_TYPE_WORD32 ⇒ 4
+ ].
+
+let rec eval_size_type (ast:ast_type) on ast ≝
+ match ast with
+  [ AST_TYPE_BASE b ⇒ eval_size_base_type b
+  | AST_TYPE_ARRAY sub_ast dim ⇒ (dim+1)*(eval_size_type sub_ast)
+  | AST_TYPE_STRUCT nel_ast ⇒ fold_right_neList ?? (λt,x.(eval_size_type t)+x) O nel_ast
+  ].
diff --git a/helm/software/matita/contribs/assembly/compiler/environment.ma b/helm/software/matita/contribs/assembly/compiler/environment.ma
new file mode 100755
index 000000000..363716ae8
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/compiler/environment.ma
@@ -0,0 +1,114 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "string/string.ma".
+include "freescale/word32.ma".
+include "compiler/ast_type.ma".
+
+(* ***************** *)
+(* GESTIONE AMBIENTE *)
+(* ***************** *)
+
+(* descrittore: const + type *)
+inductive desc_elem : Type ≝
+DESC_ELEM: bool → ast_type → desc_elem.
+
+(* elemento: name + desc *)
+inductive var_elem : Type ≝
+VAR_ELEM: aux_str_type → desc_elem → var_elem.
+
+(* ambiente globale: (ambiente base + ambienti annidati) *)
+definition aux_env_type ≝ ne_list (list var_elem).
+
+(* getter *)
+definition get_const_desc ≝ λd:desc_elem.match d with [ DESC_ELEM c _ ⇒ c ].
+definition get_type_desc ≝ λd:desc_elem.match d with [ DESC_ELEM _ t ⇒ t ].
+
+definition get_name_var ≝ λv:var_elem.match v with [ VAR_ELEM n _ ⇒ n ].
+definition get_desc_var ≝ λv:var_elem.match v with [ VAR_ELEM _ d ⇒ d ].
+
+(* ambiente vuoto *)
+definition empty_env ≝ ne_nil ? (nil var_elem ).
+
+(* setter *)
+definition enter_env ≝ λe:aux_env_type.e&empty_env.
+definition leave_env ≝ λe:aux_env_type.cut_last_neList ? e.
+
+(* recupera descrittore da ambiente *)
+let rec get_desc_from_lev_env (env:list var_elem ) (str:aux_str_type) on env ≝
+match env with
+ [ nil ⇒ None ?
+ | cons h t ⇒ match strCmp_str str (get_name_var h) with
+  [ true ⇒ Some ? (get_desc_var h)
+  | false ⇒ get_desc_from_lev_env t str ]].
+
+(* recupera descrittore da ambiente globale *)
+let rec get_desc_env_aux (env:aux_env_type) (res:option desc_elem) (str:aux_str_type) on env ≝
+ match env with
+  [ ne_nil h ⇒ match get_desc_from_lev_env h str with 
+               [ None ⇒ res | Some res' ⇒ Some ? res' ]
+  | ne_cons h t ⇒ get_desc_env_aux t (match get_desc_from_lev_env h str with 
+                                      [ None ⇒ res | Some res' ⇒ Some ? res' ]) str ].
+
+definition check_desc_env ≝ λe:aux_env_type.λstr:aux_str_type.
+ match get_desc_env_aux e (None ?) str with [ None ⇒ False | Some _ ⇒ True ].
+
+definition checkb_desc_env ≝ λe:aux_env_type.λstr:aux_str_type.
+ match get_desc_env_aux e (None ?) str with [ None ⇒ false | Some _ ⇒ true ].
+
+lemma checkbdescenv_to_checkdescenv : ∀e,str.checkb_desc_env e str = true → check_desc_env e str.
+ unfold checkb_desc_env;
+ unfold check_desc_env;
+ intros;
+ letin K ≝ (get_desc_env_aux e (None ?) str);
+ elim K;
+ [ normalize; autobatch |
+   normalize; autobatch ]
+qed.
+
+definition get_desc_env ≝ λe:aux_env_type.λstr:aux_str_type.
+ match get_desc_env_aux e (None ?) str with
+  [ None ⇒ DESC_ELEM true (AST_TYPE_BASE AST_BASE_TYPE_BYTE8) | Some x ⇒ x ].
+
+definition check_not_already_def_env ≝ λe:aux_env_type.λstr:aux_str_type.
+ match get_desc_from_lev_env (get_last_neList ? e) str with [ None ⇒ True | Some _ ⇒ False ].
+
+definition checkb_not_already_def_env ≝ λe:aux_env_type.λstr:aux_str_type.
+ match get_desc_from_lev_env (get_last_neList ? e) str with [ None ⇒ true | Some _ ⇒ false ].
+
+lemma checkbnotalreadydefenv_to_checknotalreadydefenv : ∀e,str.checkb_not_already_def_env e str = true → check_not_already_def_env e str.
+ unfold checkb_not_already_def_env;
+ unfold check_not_already_def_env;
+ intros;
+ letin K ≝ (get_desc_from_lev_env (get_last_neList ? e) str);
+ elim K;
+ [ normalize; autobatch |
+   normalize; autobatch ]
+qed.
+
+(* aggiungi descrittore ad ambiente globale *)
+definition add_desc_env ≝
+λe:aux_env_type.λstr:aux_str_type.λc:bool.λdesc:ast_type.
+let var ≝ VAR_ELEM str (DESC_ELEM c desc) in
+ match e with
+  [ ne_nil h ⇒ ne_nil ? (var::h)
+  | ne_cons _ _ ⇒ (cut_last_neList ? e)&«(var::(get_last_neList ? e)) £ »
+  ].
diff --git a/helm/software/matita/contribs/assembly/compiler/preast_to_ast.ma b/helm/software/matita/contribs/assembly/compiler/preast_to_ast.ma
new file mode 100755
index 000000000..b551582a3
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/compiler/preast_to_ast.ma
@@ -0,0 +1,480 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "compiler/preast_tree.ma".
+include "compiler/ast_tree.ma".
+
+(* *********************** *)
+(* PASSO 1 DI COMPILAZIONE *)
+(* *********************** *)
+
+(*
+ PREAST_VAR_ID: aux_str_type → preast_var
+ PREAST_VAR_ARRAY: preast_var → preast_expr → preast_var
+ PREAST_VAR_STRUCT: ne_list preast_var → nat → preast_var.
+*)
+let rec evaluate_var_type (preast:preast_var) (e:aux_env_type) on preast : option (Prod bool ast_type) ≝
+ match preast with
+  [ PREAST_VAR_ID name ⇒
+   opt_map ?? (get_desc_env_aux e (None ?) name)
+    (λdesc.Some ? (pair ?? (get_const_desc desc) (get_type_desc desc)))
+  | PREAST_VAR_ARRAY subVar expr ⇒
+   opt_map ?? (evaluate_var_type subVar e)
+    (λcDesc.match snd ?? cDesc with
+     [ AST_TYPE_ARRAY subType dim ⇒ Some ? (pair ?? (fst ?? cDesc) subType)
+     | _ ⇒ None ? ])
+  | PREAST_VAR_STRUCT subVar field ⇒
+   opt_map ?? (evaluate_var_type subVar e)
+    (λcDesc.match snd ?? cDesc with
+     [ AST_TYPE_STRUCT nelSubType ⇒
+      opt_map ?? (nth_neList ? nelSubType field)
+       (λsubType.Some ? (pair ?? (fst ?? cDesc) subType))
+     | _ ⇒ None ? ])
+  ].
+
+(*
+ PREAST_EXPR_BYTE8 : byte8 → preast_expr
+ PREAST_EXPR_WORD16: word16 → preast_expr
+ PREAST_EXPR_WORD32: word32 → preast_expr
+ PREAST_EXPR_NEG: preast_expr → preast_expr
+ PREAST_EXPR_NOT: preast_expr → preast_expr
+ PREAST_EXPR_COM: preast_expr → preast_expr
+ PREAST_EXPR_ADD: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SUB: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_MUL: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_DIV: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SHR: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SHL: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_GT : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_GTE: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_LT : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_LTE: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_EQ : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_NEQ: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_B8toW16 : preast_expr → preast_expr
+ PREAST_EXPR_B8toW32 : preast_expr → preast_expr
+ PREAST_EXPR_W16toB8 : preast_expr → preast_expr
+ PREAST_EXPR_W16toW32: preast_expr → preast_expr
+ PREAST_EXPR_W32toB8 : preast_expr → preast_expr
+ PREAST_EXPR_W32toW16: preast_expr → preast_expr
+ PREAST_EXPR_ID: preast_var → preast_expr
+*)
+let rec evaluate_expr_type (preast:preast_expr) (e:aux_env_type) on preast : option ast_base_type ≝
+ match preast with
+  [ PREAST_EXPR_BYTE8 _ ⇒ Some ? AST_BASE_TYPE_BYTE8
+  | PREAST_EXPR_WORD16 _ ⇒ Some ? AST_BASE_TYPE_WORD16
+  | PREAST_EXPR_WORD32 _ ⇒ Some ? AST_BASE_TYPE_WORD32
+  | PREAST_EXPR_NEG subExpr ⇒ evaluate_expr_type subExpr e
+  | PREAST_EXPR_NOT subExpr ⇒ evaluate_expr_type subExpr e
+  | PREAST_EXPR_COM subExpr ⇒ evaluate_expr_type subExpr e
+  | PREAST_EXPR_ADD subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? t1 | false ⇒ None ? ]))
+  | PREAST_EXPR_SUB subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? t1 | false ⇒ None ? ]))
+  | PREAST_EXPR_MUL subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? t1 | false ⇒ None ? ]))
+  | PREAST_EXPR_DIV subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? t1 | false ⇒ None ? ]))
+  | PREAST_EXPR_SHR subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t2 AST_BASE_TYPE_BYTE8 with [ true ⇒ Some ? t1 | false ⇒ None ? ]))
+  | PREAST_EXPR_SHL subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t2 AST_BASE_TYPE_BYTE8 with [ true ⇒ Some ? t1 | false ⇒ None ? ]))
+  | PREAST_EXPR_GT subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? AST_BASE_TYPE_BYTE8 | false ⇒ None ? ]))
+  | PREAST_EXPR_GTE subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? AST_BASE_TYPE_BYTE8 | false ⇒ None ? ]))
+  | PREAST_EXPR_LT subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? AST_BASE_TYPE_BYTE8 | false ⇒ None ? ]))
+  | PREAST_EXPR_LTE subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? AST_BASE_TYPE_BYTE8 | false ⇒ None ? ]))
+  | PREAST_EXPR_EQ subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? AST_BASE_TYPE_BYTE8 | false ⇒ None ? ]))
+  | PREAST_EXPR_NEQ subExpr1 subExpr2 ⇒
+   opt_map ?? (evaluate_expr_type subExpr1 e)
+    (λt1.opt_map ?? (evaluate_expr_type subExpr2 e)
+     (λt2.match eq_ast_base_type t1 t2 with [ true ⇒ Some ? AST_BASE_TYPE_BYTE8 | false ⇒ None ? ]))
+  | PREAST_EXPR_B8toW16 subExpr ⇒
+   opt_map ?? (evaluate_expr_type subExpr e)
+    (λt.match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with [ true ⇒ Some ? AST_BASE_TYPE_WORD16 | false ⇒ None ? ])
+  | PREAST_EXPR_B8toW32 subExpr ⇒
+   opt_map ?? (evaluate_expr_type subExpr e)
+    (λt.match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with [ true ⇒ Some ? AST_BASE_TYPE_WORD32 | false ⇒ None ? ])
+  | PREAST_EXPR_W16toB8 subExpr ⇒
+   opt_map ?? (evaluate_expr_type subExpr e)
+    (λt.match eq_ast_base_type t AST_BASE_TYPE_WORD16 with [ true ⇒ Some ? AST_BASE_TYPE_BYTE8 | false ⇒ None ? ])
+  | PREAST_EXPR_W16toW32 subExpr ⇒
+   opt_map ?? (evaluate_expr_type subExpr e)
+    (λt.match eq_ast_base_type t AST_BASE_TYPE_WORD16 with [ true ⇒ Some ? AST_BASE_TYPE_WORD32 | false ⇒ None ? ])
+  | PREAST_EXPR_W32toB8 subExpr ⇒
+   opt_map ?? (evaluate_expr_type subExpr e)
+    (λt.match eq_ast_base_type t AST_BASE_TYPE_WORD32 with [ true ⇒ Some ? AST_BASE_TYPE_BYTE8 | false ⇒ None ? ])
+  | PREAST_EXPR_W32toW16 subExpr ⇒
+   opt_map ?? (evaluate_expr_type subExpr e)
+    (λt.match eq_ast_base_type t AST_BASE_TYPE_WORD32 with [ true ⇒ Some ? AST_BASE_TYPE_WORD16 | false ⇒ None ? ])
+  | PREAST_EXPR_ID var ⇒
+   opt_map ?? (evaluate_var_type var e)
+    (λcDesc.match snd ?? cDesc with [ AST_TYPE_BASE bType ⇒ Some ? bType | _ ⇒ None ? ])
+  ].
+
+(*
+ PREAST_EXPR_BYTE8 : byte8 → preast_expr
+ PREAST_EXPR_WORD16: word16 → preast_expr
+ PREAST_EXPR_WORD32: word32 → preast_expr
+ PREAST_EXPR_NEG: preast_expr → preast_expr
+ PREAST_EXPR_NOT: preast_expr → preast_expr
+ PREAST_EXPR_COM: preast_expr → preast_expr
+ PREAST_EXPR_ADD: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SUB: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_MUL: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_DIV: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SHR: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SHL: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_GT : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_GTE: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_LT : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_LTE: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_EQ : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_NEQ: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_B8toW16 : preast_expr → preast_expr
+ PREAST_EXPR_B8toW32 : preast_expr → preast_expr
+ PREAST_EXPR_W16toB8 : preast_expr → preast_expr
+ PREAST_EXPR_W16toW32: preast_expr → preast_expr
+ PREAST_EXPR_W32toB8 : preast_expr → preast_expr
+ PREAST_EXPR_W32toW16: preast_expr → preast_expr
+ PREAST_EXPR_ID: preast_var → preast_expr
+*)
+let rec preast_to_ast_expr (preast:preast_expr) (e:aux_env_type) (t:ast_base_type) on preast : option (ast_expr e t) ≝
+ (*match preast
+  return λpr:preast_expr.λen:aux_env_type.λtp:ast_base_type.(match pr with
+   [ PREAST_EXPR_BYTE8 _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_WORD16 _ ⇒ option (ast_expr en AST_BASE_TYPE_WORD16)
+   | PREAST_EXPR_WORD32 _ ⇒ option (ast_expr en AST_BASE_TYPE_WORD32)
+   | PREAST_EXPR_NEG _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_NOT _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_COM _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_ADD _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_SUB _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_MUL _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_DIV _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_SHR _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_SHL _ ⇒ option (ast_expr en tp)
+   | PREAST_EXPR_GT _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_GTE _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_LT _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_LTE _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_EQ _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_NEQ _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_B8toW16 _ ⇒ option (ast_expr en AST_BASE_TYPE_WORD16)
+   | PREAST_EXPR_B8toW32 _ ⇒ option (ast_expr en AST_BASE_TYPE_WORD32)
+   | PREAST_EXPR_W16toB8 _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_W16toW32 _ ⇒ option (ast_expr en AST_BASE_TYPE_WORD32)
+   | PREAST_EXPR_W32toB8 _ ⇒ option (ast_expr en AST_BASE_TYPE_BYTE8)
+   | PREAST_EXPR_W32toW16 _ ⇒ option (ast_expr en AST_BASE_TYPE_WORD16)
+   | PREAST_EXPR_ID _ ⇒ option (ast_expr en tp)
+   | _ ⇒ option (ast_expr en tp)
+   ])
+ with
+  [ PREAST_EXPR_BYTE8 val ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ Some ? (AST_EXPR_BYTE8 e val) | false ⇒ None ? ]
+  | PREAST_EXPR_WORD16 val ⇒ match eq_ast_base_type t AST_BASE_TYPE_WORD16 with
+   [ true ⇒ Some ? (AST_EXPR_WORD16 e val) | false ⇒ None ? ]
+  | PREAST_EXPR_WORD32 val ⇒ match eq_ast_base_type t AST_BASE_TYPE_WORD32 with
+   [ true ⇒ Some ? (AST_EXPR_WORD32 e val) | false ⇒ None ? ]
+  | PREAST_EXPR_NEG subExpr ⇒
+   opt_map ?? (preast_to_ast_expr subExpr e t)
+    (λres.Some ? (AST_EXPR_NEG e t res))
+  | PREAST_EXPR_NOT subExpr ⇒
+   opt_map ?? (preast_to_ast_expr subExpr e t)
+    (λres.Some ? (AST_EXPR_NOT e t res))
+  | PREAST_EXPR_COM subExpr ⇒
+   opt_map ?? (preast_to_ast_expr subExpr e t)
+    (λres.Some ? (AST_EXPR_COM e t res))
+  | PREAST_EXPR_ADD subExpr1 subExpr2 ⇒
+   opt_map ?? (preast_to_ast_expr subExpr1 e t)
+    (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e t)
+     (λres2.Some ? (AST_EXPR_ADD e t res1 res2)))
+  | PREAST_EXPR_SUB subExpr1 subExpr2 ⇒
+   opt_map ?? (preast_to_ast_expr subExpr1 e t)
+    (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e t)
+     (λres2.Some ? (AST_EXPR_SUB e t res1 res2)))
+  | PREAST_EXPR_MUL subExpr1 subExpr2 ⇒
+   opt_map ?? (preast_to_ast_expr subExpr1 e t)
+    (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e t)
+     (λres2.Some ? (AST_EXPR_MUL e t res1 res2)))
+  | PREAST_EXPR_DIV subExpr1 subExpr2 ⇒
+   opt_map ?? (preast_to_ast_expr subExpr1 e t)
+    (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e t)
+     (λres2.Some ? (AST_EXPR_DIV e t res1 res2)))
+  | PREAST_EXPR_SHR subExpr1 subExpr2 ⇒
+   opt_map ?? (preast_to_ast_expr subExpr1 e t)
+    (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e AST_BASE_TYPE_BYTE8)
+     (λres2.Some ? (AST_EXPR_SHR e t res1 res2)))
+  | PREAST_EXPR_SHL subExpr1 subExpr2 ⇒
+   opt_map ?? (preast_to_ast_expr subExpr1 e t)
+    (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e AST_BASE_TYPE_BYTE8)
+     (λres2.Some ? (AST_EXPR_SHL e t res1 res2)))
+  | PREAST_EXPR_GT subExpr1 subExpr2 ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ opt_map ?? (evaluate_expr_type subExpr1 e)
+             (λresType.opt_map ?? (preast_to_ast_expr subExpr1 e resType)
+              (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e resType)
+               (λres2.Some ? (AST_EXPR_GT e resType res1 res2))))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_GTE subExpr1 subExpr2 ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ opt_map ?? (evaluate_expr_type subExpr1 e)
+             (λresType.opt_map ?? (preast_to_ast_expr subExpr1 e resType)
+              (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e resType)
+               (λres2.Some ? (AST_EXPR_GTE e resType res1 res2))))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_LT subExpr1 subExpr2 ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ opt_map ?? (evaluate_expr_type subExpr1 e)
+             (λresType.opt_map ?? (preast_to_ast_expr subExpr1 e resType)
+              (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e resType)
+               (λres2.Some ? (AST_EXPR_LT e resType res1 res2))))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_LTE subExpr1 subExpr2 ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ opt_map ?? (evaluate_expr_type subExpr1 e)
+             (λresType.opt_map ?? (preast_to_ast_expr subExpr1 e resType)
+              (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e resType)
+               (λres2.Some ? (AST_EXPR_LTE e resType res1 res2))))   
+   | false ⇒ None ? ]
+  | PREAST_EXPR_EQ subExpr1 subExpr2 ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ opt_map ?? (evaluate_expr_type subExpr1 e)
+             (λresType.opt_map ?? (preast_to_ast_expr subExpr1 e resType)
+              (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e resType)
+               (λres2.Some ? (AST_EXPR_EQ e resType res1 res2))))   
+   | false ⇒ None ? ]
+  | PREAST_EXPR_NEQ subExpr1 subExpr2 ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ opt_map ?? (evaluate_expr_type subExpr1 e)
+             (λresType.opt_map ?? (preast_to_ast_expr subExpr1 e resType)
+              (λres1.opt_map ?? (preast_to_ast_expr subExpr2 e resType)
+               (λres2.Some ? (AST_EXPR_NEQ e resType res1 res2))))   
+   | false ⇒ None ? ]
+  | PREAST_EXPR_B8toW16 subExpr ⇒ match eq_ast_base_type t AST_BASE_TYPE_WORD16 with
+   [ true ⇒ opt_map ?? (preast_to_ast_expr subExpr e AST_BASE_TYPE_BYTE8)
+    (λres.Some ? (AST_EXPR_B8toW16 e res))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_B8toW32 subExpr ⇒ match eq_ast_base_type t AST_BASE_TYPE_WORD32 with
+   [ true ⇒ opt_map ?? (preast_to_ast_expr subExpr e AST_BASE_TYPE_BYTE8)
+    (λres.Some ? (AST_EXPR_B8toW32 e res))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_W16toB8 subExpr ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ opt_map ?? (preast_to_ast_expr subExpr e AST_BASE_TYPE_WORD16)
+    (λres.Some ? (AST_EXPR_W16toB8 e res))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_W16toW32 subExpr ⇒ match eq_ast_base_type t AST_BASE_TYPE_WORD32 with
+   [ true ⇒ opt_map ?? (preast_to_ast_expr subExpr e AST_BASE_TYPE_WORD16)
+    (λres.Some ? (AST_EXPR_W16toW32 e res))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_W32toB8 subExpr ⇒ match eq_ast_base_type t AST_BASE_TYPE_BYTE8 with
+   [ true ⇒ opt_map ?? (preast_to_ast_expr subExpr e AST_BASE_TYPE_WORD32)
+    (λres.Some ? (AST_EXPR_W32toB8 e res))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_W32toW16 subExpr ⇒ match eq_ast_base_type t AST_BASE_TYPE_WORD16 with
+   [ true ⇒ opt_map ?? (preast_to_ast_expr subExpr e AST_BASE_TYPE_WORD32)
+    (λres.Some ? (AST_EXPR_W32toW16 e res))
+   | false ⇒ None ? ]
+  | PREAST_EXPR_ID var ⇒
+   opt_map ?? (evaluate_var_type var e)
+    (λcDesc.opt_map ?? (preast_to_ast_var var e (fst ?? cDesc) (AST_TYPE_BASE t))
+     (λres.Some ? (AST_EXPR_ID e (fst ?? cDesc) t res)))
+  ]*)
+ None (ast_expr e t)
+(*
+ PREAST_VAR_ID: aux_str_type → preast_var
+ PREAST_VAR_ARRAY: preast_var → preast_expr → preast_var
+ PREAST_VAR_STRUCT: preast_var → nat → preast_var.
+*)
+and preast_to_ast_var (preast:preast_var) (e:aux_env_type) (c:bool) (t:ast_type) on preast : option (ast_var e c t) ≝
+ None (ast_var e c t)
+(*
+ PREAST_EXPR_BYTE8 : byte8 → preast_expr
+ PREAST_EXPR_WORD16: word16 → preast_expr
+ PREAST_EXPR_WORD32: word32 → preast_expr
+ PREAST_EXPR_NEG: preast_expr → preast_expr
+ PREAST_EXPR_NOT: preast_expr → preast_expr
+ PREAST_EXPR_COM: preast_expr → preast_expr
+ PREAST_EXPR_ADD: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SUB: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_MUL: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_DIV: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SHR: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_SHL: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_GT : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_GTE: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_LT : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_LTE: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_EQ : preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_NEQ: preast_expr → preast_expr → preast_expr
+ PREAST_EXPR_B8toW16 : preast_expr → preast_expr
+ PREAST_EXPR_B8toW32 : preast_expr → preast_expr
+ PREAST_EXPR_W16toB8 : preast_expr → preast_expr
+ PREAST_EXPR_W16toW32: preast_expr → preast_expr
+ PREAST_EXPR_W32toB8 : preast_expr → preast_expr
+ PREAST_EXPR_W32toW16: preast_expr → preast_expr
+ PREAST_EXPR_ID: preast_var → preast_expr
+*)
+and preast_to_ast_base_expr (preast:preast_expr) (e:aux_env_type) on preast : option (ast_base_expr e) ≝
+ None (ast_base_expr e).
+
+(*
+ PREAST_STM_ASG: preast_var → preast_expr → preast_stm
+ PREAST_STM_WHILE: preast_expr → preast_decl → preast_stm
+ PREAST_STM_IF: ne_list (Prod preast_expr preast_decl) → option preast_decl → preast_stm
+*)
+let rec preast_to_ast_stm (preast:preast_stm) (e:aux_env_type) on preast : option (ast_stm e) ≝
+ match preast with
+  (* (A) assegnamento *)
+  [ PREAST_STM_ASG var expr ⇒
+   opt_map ?? (evaluate_var_type var e)
+    (λcDesc.match fst ?? cDesc with
+     (* NO: left non deve essere read only *)
+     [ true ⇒ None ?
+     (* OK: left e' read write *)
+     | false ⇒
+      match isntb_ast_base_type (snd ?? cDesc)
+       return λx.(isntb_ast_base_type (snd ?? cDesc)) = x → option (ast_stm e)
+      with
+      (* (A.1) memcpy *)
+      [ true ⇒ λp:(isntb_ast_base_type (snd ?? cDesc)) = true.match expr with
+       (* OK: right deve essere una var *)
+       [ PREAST_EXPR_ID subVar ⇒ opt_map ?? (evaluate_var_type subVar e)
+        (λcDesc'.opt_map ?? (preast_to_ast_var var e false (snd ?? cDesc))
+         (λresVar.opt_map ?? (preast_to_ast_var subVar e (fst ?? cDesc') (snd ?? cDesc))
+          (λresVar'.Some ? (AST_STM_MEMCPY_ASG e (fst ?? cDesc') (snd ?? cDesc)
+                                               (isntbastbasetype_to_isntastbasetype (snd ?? cDesc) p)
+                                               resVar resVar'))))
+       (* NO: right non e' una var *)
+       | _ ⇒ None ? ]
+      (* (A.2) variabile *)
+      | false ⇒ λp:(isntb_ast_base_type (snd ?? cDesc)) = false.match snd ?? cDesc with
+       [ AST_TYPE_BASE bType ⇒ opt_map ?? (preast_to_ast_expr expr e bType)
+       (λresExpr.opt_map ?? (preast_to_ast_var var e false (AST_TYPE_BASE bType))
+        (λresVar.Some ? (AST_STM_ASG e bType resVar resExpr)))
+       | _ ⇒ None ? ]] (refl_eq ? (isntb_ast_base_type (snd ?? cDesc)))
+     ])
+
+  (* (B) while *)
+  | PREAST_STM_WHILE expr decl ⇒
+   opt_map ?? (preast_to_ast_base_expr expr e)
+    (λresExpr.opt_map ?? (preast_to_ast_decl decl e)
+     (λresDecl.Some ? (AST_STM_WHILE e resExpr resDecl)))
+
+  (* (C) if *)
+  | PREAST_STM_IF nelExprDecl optDecl ⇒
+   opt_map ?? (fold_right_neList ?? (λh,t.opt_map ?? (preast_to_ast_base_expr (fst ?? h) e)
+                                     (λresExpr.opt_map ?? (preast_to_ast_decl (snd ?? h) e)
+                                      (λresDecl.opt_map ?? t
+                                       (λt'.Some ? («(pair ?? resExpr resDecl)£»&t')))))
+                                    (Some ? (ne_nil ? (pair ?? (AST_BASE_EXPR e AST_BASE_TYPE_BYTE8 (AST_EXPR_BYTE8 e 〈x0,x0〉)) (AST_NO_DECL e (nil ?)))))
+                                    nelExprDecl)
+    (λres.match optDecl with
+     [ None ⇒ Some ? (AST_STM_IF e (cut_last_neList ? res) (None ?))
+     | Some decl ⇒ opt_map ?? (preast_to_ast_decl decl e)
+      (λresDecl.Some ? (AST_STM_IF e (cut_last_neList ? res) (Some ? resDecl)))
+     ])
+  ]
+(* 
+ PREAST_NO_DECL: list preast_stm → preast_decl
+ PREAST_DECL: bool → aux_str_type → ast_type → option preast_expr → preast_decl → preast_decl.
+*)
+and preast_to_ast_decl (preast:preast_decl) (e:aux_env_type) on preast : option (ast_decl e) ≝
+ match preast with
+  (* (A) nessuna dichiarazione, solo statement *)
+  [ PREAST_NO_DECL lPreastStm ⇒
+   opt_map ?? (fold_right_list ?? (λh,t.opt_map ?? (preast_to_ast_stm h e)
+                                   (λh'.opt_map ?? t
+                                    (λt'.Some ? ([h']@t')))) (Some ? (nil ?)) lPreastStm)  
+    (λres.Some ? (AST_NO_DECL e res))
+
+  (* (B) dichiarazione *)
+  | PREAST_DECL constFlag decName decType optInitExpr subPreastDecl ⇒
+   match checkb_not_already_def_env e decName 
+    return λx.(checkb_not_already_def_env e decName) = x → option (ast_decl e)
+   with
+    (* OK: non era gia' dichiarata *)
+    [ true ⇒ λp:(checkb_not_already_def_env e decName) = true.
+     match decType with
+      (* (B.1) dichiarazione tipo base *)
+      [ AST_TYPE_BASE decBaseType ⇒ match optInitExpr with
+       (* (B.1.1) tipo base senza inizializzazione *)
+       [ None ⇒ opt_map ?? (preast_to_ast_decl subPreastDecl (add_desc_env e decName constFlag (AST_TYPE_BASE decBaseType)))
+                 (λsubRes.Some ? (AST_BASE_DECL e constFlag decName decBaseType
+                                                (checkbnotalreadydefenv_to_checknotalreadydefenv e decName p)
+                                                (None ?) subRes))
+       (* (B.1.2) tipo base con inizializzazione *)
+       | Some initExpr ⇒ opt_map ?? (preast_to_ast_expr initExpr e decBaseType)
+                          (λinitRes.opt_map ?? (preast_to_ast_decl subPreastDecl (add_desc_env e decName constFlag (AST_TYPE_BASE decBaseType)))
+                           (λsubRes.Some ? (AST_BASE_DECL e constFlag decName decBaseType
+                                                          (checkbnotalreadydefenv_to_checknotalreadydefenv e decName p)
+                                                          (None ?) subRes)))
+       ]
+      (* (B.2) dichiarazione record/struttura *)
+      | _ ⇒ match optInitExpr with
+       (* OK: senza inizializzazione *)
+       [ None ⇒ match isntb_ast_base_type decType
+                 return λy.(isntb_ast_base_type decType) = y → option (ast_decl e)
+                with
+                 [ true ⇒ λp':(isntb_ast_base_type decType) = true.
+                  opt_map ?? (preast_to_ast_decl subPreastDecl (add_desc_env e decName constFlag decType))
+                 (λsubRes.Some ? (AST_DECL e constFlag decName decType
+                                           (checkbnotalreadydefenv_to_checknotalreadydefenv e decName p)
+                                           (isntbastbasetype_to_isntastbasetype decType p')
+                                           subRes))
+                 | false ⇒ λp':(isntb_ast_base_type decType) = false.None ?
+                 ] (refl_eq ? (isntb_ast_base_type decType))
+       (* NO: con inizializzazione *)
+       | Some _ ⇒ None ?
+       ]
+      ]
+    (* NO: era gia' dichiarata *)
+    | false ⇒ λp:(checkb_not_already_def_env e decName) = false.None ?     
+    ] (refl_eq ? (checkb_not_already_def_env e decName))     
+  ].
+
+(*
+ PREAST_ROOT: preast_decl → preast_root.
+*)
+definition preast_to_ast ≝
+λpreast:preast_root.match preast with
+ [ PREAST_ROOT decl ⇒ opt_map ?? (preast_to_ast_decl decl empty_env)
+                       (λres.Some ? (AST_ROOT res)) ].
diff --git a/helm/software/matita/contribs/assembly/compiler/preast_tree.ma b/helm/software/matita/contribs/assembly/compiler/preast_tree.ma
new file mode 100755
index 000000000..fcc1fbf4a
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/compiler/preast_tree.ma
@@ -0,0 +1,92 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "string/string.ma".
+include "compiler/utility.ma".
+include "freescale/word32.ma".
+include "compiler/ast_type.ma".
+
+(* ****************** *)
+(* PREALBERO DI TOKEN *)
+(* ****************** *)
+
+(* espressioni *)
+inductive preast_expr : Type ≝
+  PREAST_EXPR_BYTE8 : byte8 → preast_expr
+| PREAST_EXPR_WORD16: word16 → preast_expr
+| PREAST_EXPR_WORD32: word32 → preast_expr
+
+| PREAST_EXPR_NEG: preast_expr → preast_expr
+| PREAST_EXPR_NOT: preast_expr → preast_expr
+| PREAST_EXPR_COM: preast_expr → preast_expr
+
+| PREAST_EXPR_ADD: preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_SUB: preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_MUL: preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_DIV: preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_SHR: preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_SHL: preast_expr → preast_expr → preast_expr
+
+| PREAST_EXPR_GT : preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_GTE: preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_LT : preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_LTE: preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_EQ : preast_expr → preast_expr → preast_expr
+| PREAST_EXPR_NEQ: preast_expr → preast_expr → preast_expr
+
+| PREAST_EXPR_B8toW16 : preast_expr → preast_expr
+| PREAST_EXPR_B8toW32 : preast_expr → preast_expr
+| PREAST_EXPR_W16toB8 : preast_expr → preast_expr
+| PREAST_EXPR_W16toW32: preast_expr → preast_expr
+| PREAST_EXPR_W32toB8 : preast_expr → preast_expr
+| PREAST_EXPR_W32toW16: preast_expr → preast_expr
+
+| PREAST_EXPR_ID: preast_var → preast_expr
+
+(* variabile: modificatori di array/struct dell'id *)
+with preast_var : Type ≝
+  PREAST_VAR_ID: aux_str_type → preast_var
+| PREAST_VAR_ARRAY: preast_var → preast_expr → preast_var
+| PREAST_VAR_STRUCT: preast_var → nat → preast_var.
+
+(* -------------------------- *)
+
+(* statement: assegnamento/while/if else if else *)
+inductive preast_stm : Type ≝
+  PREAST_STM_ASG: preast_var → preast_expr → preast_stm
+| PREAST_STM_WHILE: preast_expr → preast_decl → preast_stm
+| PREAST_STM_IF: ne_list (Prod preast_expr preast_decl) → option preast_decl → preast_stm
+
+(* dichiarazioni *)
+with preast_decl : Type ≝
+  PREAST_NO_DECL: list preast_stm → preast_decl
+| PREAST_DECL: bool → aux_str_type → ast_type → option preast_expr → preast_decl → preast_decl.
+
+(* -------------------------- *)
+
+(* programma *)
+inductive preast_root : Type ≝
+  PREAST_ROOT: preast_decl → preast_root.
+
+(* -------------------------- *)
+
+(* programma vuoto *)
+definition empty_preast_prog ≝ PREAST_ROOT (PREAST_NO_DECL (nil ?)).
diff --git a/helm/software/matita/contribs/assembly/compiler/utility.ma b/helm/software/matita/contribs/assembly/compiler/utility.ma
new file mode 100755
index 000000000..4352dc426
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/compiler/utility.ma
@@ -0,0 +1,204 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "freescale/extra.ma".
+
+(* ************** *)
+(* Non-Empty List *)
+(* ************** *)
+
+(* lista non vuota *)
+inductive ne_list (A:Type) : Type ≝
+  | ne_nil: A → ne_list A
+  | ne_cons: A → ne_list A → ne_list A.
+
+(* append *)
+let rec ne_append (A:Type) (l1,l2:ne_list A) on l1 ≝
+ match l1 with
+  [ ne_nil hd => ne_cons A hd l2
+  | ne_cons hd tl => ne_cons A hd (ne_append A tl l2) ].
+
+notation "hvbox(hd break §§ tl)"
+  right associative with precedence 46
+  for @{'ne_cons $hd $tl}.
+
+notation "« y £ break list0 x sep ; »"
+  non associative with precedence 90
+  for ${fold right @{'ne_nil $y } rec acc @{'ne_cons $x $acc}}.
+
+notation "hvbox(l1 break & l2)"
+  right associative with precedence 47
+  for @{'ne_append $l1 $l2 }.
+
+interpretation "ne_nil" 'ne_nil hd = (ne_nil _ hd).
+interpretation "ne_cons" 'ne_cons hd tl = (ne_cons _ hd tl).
+interpretation "ne_append" 'ne_append l1 l2 = (ne_append _ l1 l2).
+
+(* ************ *)
+(* List Utility *)
+(* ************ *)
+
+(* conversione *)
+let rec neList_to_list (T:Type) (p_l:ne_list T) on p_l ≝
+ match p_l with [ ne_nil h ⇒ [h] | ne_cons h t ⇒ [h]@neList_to_list T t ].
+
+let rec list_to_neList (T:Type) (p_l:list T) on p_l ≝
+ match p_l with [ nil ⇒ None (ne_list T) | cons h t ⇒ match list_to_neList T t with [ None ⇒ Some ? «h£» | Some t' ⇒ Some ? («h£»&t') ]].
+
+(* listlen *)
+let rec len_list_aux (T:Type) (p_l:list T) (c:nat) on p_l ≝
+ match p_l with [ nil ⇒ c | cons _ t ⇒ len_list_aux T t (S c) ].
+
+definition len_list ≝ λT:Type.λl:list T.len_list_aux T l O.
+
+let rec len_neList_aux (T:Type) (p_l:ne_list T) (c:nat) on p_l ≝
+ match p_l with [ ne_nil _ ⇒ (S c) | ne_cons _ t ⇒ len_neList_aux T t (S c) ].
+
+definition len_neList ≝ λT:Type.λl:ne_list T.len_neList_aux T l O.
+
+(* nth elem *)
+let rec nth_list (T:Type) (l:list T) (n:nat) on l ≝
+ match l with
+  [ nil ⇒ None ?
+  | cons h t ⇒ match n with
+   [ O ⇒ Some ? h | S n' ⇒ nth_list T t n' ]
+  ].
+
+let rec nth_neList (T:Type) (l:ne_list T) (n:nat) on l ≝
+ match l with
+  [ ne_nil h ⇒ match n with
+   [ O ⇒ Some ? h | S _ ⇒ None ? ]
+  | ne_cons h t ⇒ match n with
+   [ O ⇒ Some ? h | S n' ⇒ nth_neList T t n' ]
+  ].
+
+let rec abs_nth_neList (T:Type) (l:ne_list T) (n:nat) on l ≝
+ match l with
+  [ ne_nil h ⇒ h
+  | ne_cons h t ⇒ match n with
+   [ O ⇒ h | S n' ⇒ abs_nth_neList T t n' ]
+  ].
+
+(* reverse *)
+let rec reverse_list_aux (T:Type) (lin:list T) (lout:list T) on lin ≝
+ match lin with [ nil ⇒ lout | cons h t ⇒ reverse_list_aux T t (h::lout) ].
+
+definition reverse_list ≝ λT:Type.λl:list T.reverse_list_aux T l (nil T).
+
+let rec reverse_neList_aux (T:Type) (lin:ne_list T) (lout:ne_list T) on lin ≝
+ match lin with [ ne_nil h ⇒ h§§lout | ne_cons h t ⇒ reverse_neList_aux T t (h§§lout) ].
+
+definition reverse_neList ≝ λT:Type.λl:ne_list T.
+ match l with
+  [ ne_nil h ⇒ l
+  | ne_cons h t ⇒ reverse_neList_aux T t (ne_nil T h)
+  ].
+
+(* getLast *)
+definition get_last_list ≝
+λT:Type.λl:list T.match reverse_list T l with
+ [ nil ⇒ None ?
+ | cons h _ ⇒ Some ? h ].
+
+definition get_last_neList ≝
+λT:Type.λl:ne_list T.match reverse_neList T l with
+ [ ne_nil h ⇒ h
+ | ne_cons h _ ⇒ h ].
+
+(* cutLast *)
+definition cut_last_list ≝
+λT:Type.λl:list T.match reverse_list T l with
+ [ nil ⇒ nil T
+ | cons _ t ⇒ reverse_list T t ].
+
+definition cut_last_neList ≝
+λT:Type.λl:ne_list T.match reverse_neList T l with
+ [ ne_nil h ⇒ ne_nil T h
+ | ne_cons _ t ⇒ reverse_neList T t ].
+
+(* apply f *)
+let rec apply_f_list (T1,T2:Type) (l:list T1) (f:T1 → T2) on l ≝
+match l with
+ [ nil ⇒ nil T2
+ | cons h t ⇒ cons T2 (f h) (apply_f_list T1 T2 t f) ].
+
+let rec apply_f_neList (T1,T2:Type) (l:ne_list T1) (f:T1 → T2) on l ≝
+match l with
+ [ ne_nil h ⇒ ne_nil T2 (f h)
+ | ne_cons h t ⇒ ne_cons T2 (f h) (apply_f_neList T1 T2 t f) ].
+
+(* fold right *)
+definition fold_right_list ≝
+λT1,T2:Type.λf:T1 → T2 → T2.λacc:T2.
+ let rec aux (l:list T1) on l ≝
+  match l with
+   [ nil ⇒ acc
+   | cons h t ⇒ f h (aux t)
+   ] in
+  aux.
+
+definition fold_right_neList ≝
+λT1,T2:Type.λf:T1 → T2 → T2.λacc:T2.
+ let rec aux (nel:ne_list T1) on nel ≝
+  match nel with
+   [ ne_nil h ⇒ f h acc
+   | ne_cons h t ⇒ f h (aux t)
+   ] in
+  aux.
+
+(* vuota? *)
+definition is_empty_list ≝
+λT:Type.λl:list T.match l with [ nil ⇒ True | cons _ _ ⇒ False ].
+
+definition isb_empty_list ≝
+λT:Type.λl:list T.match l with [ nil ⇒ true | cons _ _ ⇒ false ].
+
+lemma isbemptylist_to_isemptylist : ∀T,l.isb_empty_list T l = true → is_empty_list T l.
+ unfold isb_empty_list;
+ unfold is_empty_list;
+ intros;
+ elim l;
+ [ normalize; autobatch |
+   normalize; autobatch ]
+qed.
+
+(* ******** *)
+(* naturali *)
+(* ******** *)
+
+definition isZero ≝ λn:nat.match n with [ O ⇒ True | S _ ⇒ False ].
+
+definition isZerob ≝ λn:nat.match n with [ O ⇒ true | S _ ⇒ false ].
+
+lemma iszerob_to_iszero : ∀n.isZerob n = true → isZero n.
+ unfold isZerob;
+ unfold isZero;
+ intros;
+ elim n;
+ [ normalize; autobatch |
+   normalize; autobatch ]
+qed.
+
+definition ltb ≝ λn1,n2:nat.(leb n1 n2) ⊗ (⊖ (eqb n1 n2)).
+
+definition geb ≝ λn1,n2:nat.(⊖ (leb n1 n2)) ⊕ (eqb n1 n2).
+
+definition gtb ≝ λn1,n2:nat.⊖ (leb n1 n2).
diff --git a/helm/software/matita/contribs/assembly/depends b/helm/software/matita/contribs/assembly/depends
index 049af9f67..8038c648e 100644
--- a/helm/software/matita/contribs/assembly/depends
+++ b/helm/software/matita/contribs/assembly/depends
@@ -1,31 +1,40 @@
-freescale/translation.ma freescale/table_HC05.ma freescale/table_HC08.ma freescale/table_HCS08.ma freescale/table_RS08.ma
+string/ascii_min.ma freescale/byte8.ma
+string/string.ma compiler/utility.ma string/ascii_min.ma
+compiler/ast_tree.ma compiler/environment.ma
+compiler/preast_tree.ma compiler/ast_type.ma compiler/utility.ma freescale/word32.ma string/string.ma
+compiler/environment.ma compiler/ast_type.ma freescale/word32.ma string/string.ma
+compiler/utility.ma freescale/extra.ma
+compiler/ast_type.ma compiler/utility.ma freescale/word32.ma
+compiler/preast_to_ast.ma compiler/ast_tree.ma compiler/preast_tree.ma
+freescale/extra.ma datatypes/constructors.ma list/list.ma logic/connectives.ma nat/div_and_mod.ma nat/primes.ma
 freescale/table_RS08_tests.ma freescale/table_RS08.ma
+freescale/table_HC05_tests.ma freescale/table_HC05.ma
+freescale/load_write.ma freescale/model.ma
+freescale/byte8.ma freescale/exadecim.ma
 freescale/table_HCS08.ma freescale/opcode.ma
-freescale/table_RS08.ma freescale/opcode.ma
-freescale/memory_trees.ma freescale/memory_struct.ma
 freescale/multivm.ma freescale/load_write.ma
+freescale/translation.ma freescale/table_HC05.ma freescale/table_HC08.ma freescale/table_HCS08.ma freescale/table_RS08.ma
+freescale/model.ma freescale/status.ma
+freescale/medium_tests_lemmas.ma freescale/medium_tests_tools.ma
+freescale/medium_tests.ma freescale/medium_tests_lemmas.ma
+freescale/table_HC08.ma freescale/opcode.ma
 freescale/opcode.ma freescale/aux_bases.ma
-freescale/memory_func.ma freescale/memory_struct.ma
-freescale/micro_tests.ma freescale/multivm.ma
+freescale/memory_trees.ma freescale/memory_struct.ma
+freescale/table_HCS08_tests.ma freescale/table_HCS08.ma
 freescale/exadecim.ma freescale/extra.ma
-freescale/table_HC08.ma freescale/opcode.ma
-freescale/table_HC05.ma freescale/opcode.ma
-freescale/memory_bits.ma freescale/memory_trees.ma
 freescale/word16.ma freescale/byte8.ma
-freescale/table_HC08_tests.ma freescale/table_HC08.ma
-freescale/table_HC05_tests.ma freescale/table_HC05.ma
-freescale/model.ma freescale/status.ma
-freescale/medium_tests.ma freescale/medium_tests_lemmas.ma
 freescale/medium_tests_tools.ma freescale/multivm.ma
-freescale/load_write.ma freescale/model.ma
-freescale/memory_struct.ma freescale/translation.ma
-freescale/table_HCS08_tests.ma freescale/table_HCS08.ma
+freescale/status.ma freescale/memory_abs.ma
+freescale/memory_func.ma freescale/memory_struct.ma
+freescale/memory_bits.ma freescale/memory_trees.ma
+freescale/table_HC08_tests.ma freescale/table_HC08.ma
+freescale/micro_tests.ma freescale/multivm.ma
 freescale/memory_abs.ma freescale/memory_bits.ma freescale/memory_func.ma freescale/memory_trees.ma
-freescale/extra.ma datatypes/constructors.ma list/list.ma logic/connectives.ma nat/div_and_mod.ma nat/primes.ma
+freescale/table_RS08.ma freescale/opcode.ma
+freescale/table_HC05.ma freescale/opcode.ma
 freescale/aux_bases.ma freescale/word16.ma
-freescale/medium_tests_lemmas.ma freescale/medium_tests_tools.ma
-freescale/status.ma freescale/memory_abs.ma
-freescale/byte8.ma freescale/exadecim.ma
+freescale/memory_struct.ma freescale/translation.ma
+freescale/word32.ma freescale/word16.ma
 datatypes/constructors.ma 
 list/list.ma 
 logic/connectives.ma 
diff --git a/helm/software/matita/contribs/assembly/freescale/Doc/counting_sort.txt b/helm/software/matita/contribs/assembly/freescale/Doc/counting_sort.txt
new file mode 100755
index 000000000..cb63d9c65
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/freescale/Doc/counting_sort.txt
@@ -0,0 +1,613 @@
+PROCESSORE
+
+A : 0x00
+PC: 0x18C8 -> 0x1966
+SP: 0x0F4B
+HX: 0x0F4C
+Status: I=1 Z=1
+
+TEMPI COMPLETI
+0   esempi: 183941 -> 219568: 35627 tick
+10  esempi: 183941 -> 221074: 37133 =35633+  10*150 tick
+20  esempi: 183941 -> 222573: 38632 =35632+  20*150 tick
+30  esempi: 183941 -> 224063: 40122 =35622+  30*150 tick
+40  esempi: 183941 -> 225553: 41612 =35612+  40*150 tick
+50  esempi: 183941 -> 227043: 43102 =35602+  50*150 tick
+100 esempi: 183941 -> 234493: 50552 =35552+ 100*150 tick
+200 esempi: 183941 -> 249393: 65453 =35453+ 200*150 tick
+
+oltre bisogna introdurre __RESET_WATCHDOG(); e quindi approssimare ancora di piu'
+
+500 esempi: 183941 -> 297886: 113945=38945+500 *150 tick
+ => con tara di (256+500)*4=3024 e' 35921+...
+1024esempi: 183941 -> 378070: 194129=40529+1024*150 tick
+ => con tara di (256+1024)*4=5120 e' 35409+...
+2048esempi: 183941 -> 534758: 350817=43617+2048*150 tick
+ => con tara di (256+2048)*4=9216 e' 34401+...
+3072esempi: 183941 -> 691446: 507505=46705+3072*150 tick
+ => con tara di (256+3072)*4=13312 e' 33393+...
+
+si puo' quindi dare un'interpretazione del tipo T(n)=fix+n*esempi=36000+150n
+chiaramente utile solo per definire un bound superiore 
+
+NB: per l'ultimo 1s circa di esecuzione con emulatore,
+    tutti questi esempi sono stati fatti girare in emulazione
+    e non con IN-CIRCUIT debug.
+
+NB: __RESET_WATCHDOG(); e' in pratica una singola istruzione
+    STA 0x1800 cioe' scrivi qualsiasi cosa su locazione di reset (4 tick)
+
+TEMPI PARZIALI
+1) senza ripristino di counters, index, position...
+2) calcolati con tara di _RESET_WATCHDOG() sempre per uniformare
+
+0   : 183941 -> 209557:  25616: ( 25616+   0*4): k          :  25700 >  25616
+8   : 183941 -> 210794:  26853: ( 26821+   8*4): k+150.62*n :  26900 >  26821
+16  : 183941 -> 212018:  28077: ( 28013+  16*4): k+149.81*n :  28100 >  28013
+32  : 183941 -> 214466:  30525: ( 30397+  32*4): k+149.41*n :  30500 >  30397
+64  : 183941 -> 219362:  35421: ( 35165+  64*4): k+149.20*n :  35300 >  35165
+128 : 183941 -> 229154:  45213: ( 44701+ 128*4): k+149.10*n :  44900 >  44701
+256 : 183941 -> 248742:  64801: ( 63777+ 256*4): k+149.07*n :  64100 >  63777
+512 : 183941 -> 287914: 103973: (101925+ 512*4): k+149.04*n : 102500 > 101925
+1024: 183941 -> 366258: 182317: (178221+1024*4): k+149.03*n : 179300 > 178221
+2048: 183941 -> 522946: 339005: (330813+2048*4): k+149.02*n : 332900 > 330813
+3072: 183941 -> 679634: 495693: (483405+3072*4): k+149.02*n : 486500 > 483405
+
+quindi generalizziamo in T(n)=25700+150*n (0x6464+0x96*n)
+
+ma registri diversi
+A : 0x00   -> 0xFF
+PC: 0x18C8 -> 0x193B
+SP: 0x0F4B
+HX: 0x0F4C -> 0x0100
+Status: I=1 Z=1
+
+LOCAZIONI
+dati=3072 byte [100-CFF]
+counters=256 word [D00-EFF]
+index=1 word [F4C-F4D]
+position=1 word [F4E-F4F]
+
+(fine RAM a 0x107F)
+=> poiche' counters e stack finali sono difficili da formalizzare meglio azzerare
+   da 0x0D00 a 0x107F, cioe' 380 (1KB - 0x80, la zona iniziale non usata)
+
+sostanzialmente si puo' riassumere in tesi:
+ tutto a 0 tranne dati
+
+***********************************
+
+static unsigned int counters[256]={ 0, ... };
+static unsigned char dati[3072]={ ... };
+
+void sort(void)
+{
+unsigned int index=0,position=0;
+
+/* prologo: si puo' saltare e inglobare nell'ipotesi */
+
+for(;index<3072;index++)
+    {
+    __RESET_WATCHDOG(); /* #solo per esempi > 200 */
+    counters[dati[index]]++;
+    }
+
+jmp blocco controllo del for
+18C8 20 1D       BRA *+31 ; 18E7
+corpo del for
+18CA 9E FE 01    LDHX 1,SP
+18CD D6 01 00    LDA 256,X
+18D0 48          LSLA
+18D1 5F          CLRX
+18D2 59          ROLX
+18D3 AB 00       ADD #0X00
+18D5 87          PSHA
+18D6 9F          TXA
+18D7 A9 0D       ADC #0X0D
+18D9 87          PSHA
+18DA 8A          PULH
+18DB 88          PULX
+passo del for
+18DC 6C 01       INC 1,X
+18DE 26 01       BNE *+3 ; 18E1
+18E0 7C          INC ,X
+18E1 95          TSX
+18E2 6C 01       INC 1,X
+18E4 26 01       BNE *+3 ; 18E7
+18E6 7C          INC ,X
+blocco controllo del for
+18E7 9E FE 01    LDHX 1,SP
+18EA 65 0C 00    CPHX #0X0C00 ; DIMENSIONE DEI DATI
+18ED 25 DB       BCS *-35 ; 18CA
+uscita dal for
+
+for(index=0;index<256;index++)
+    {
+    __RESET_WATCHDOG(); /* #solo per esempi > 200 */
+    while(counters[index]--)
+        { dati[position++]=index; }
+    }
+
+init del for
+18EF 95          TSX
+18F0 6F 01       CLR 1,X
+18F2 7F          CLR ,X
+salto a condizione del while
+18F3 20 0E       BRA *+16 ; 1903
+corpo del while
+18F5 95          TSX
+18F6 E6 01       LDA 1,X
+18F8 9E FE 03    LDHX 3,SP
+18FB D7 01 00    STA 256,X
+18FE AF 01       AIX #1
+1900 9E FF 03    STHX 3,SP
+condizione del while
+1903 95          TSX
+1904 EE 01       LDX 1,X
+1906 58          LSLX
+1907 9E E6 01    LDA 1,SP
+190A 49          ROLA
+190B 87          PSHA
+190C 8A          PULH
+190D 89          PSHX
+190E 9E BE 0D 00 LDHX 3328,X
+1912 89          PSHX
+1913 8B          PSHH
+1914 AF FF       AIX #-1
+1916 8B          PSHH
+1917 87          PSHA
+1918 8A          PULH
+1919 89          PSHX
+191A 9E EE 05    LDX 5,SP
+191D 86          PULA
+191E D7 0D 01    STA 3329,X
+1921 86          PULA
+1922 D7 0D 00    STA 3328,X
+1925 8A          PULH
+1926 88          PULX
+1927 65 00 00    CPHX #0X0000
+192A 8A          PULH
+192B 26 C8       BNE *-54 ; 18F5
+uscita dal while/passo del for
+192D 95          TSX
+192E 6C 01       INC 1,X
+1930 26 01       BNE *+3 ; 1933
+1932 7C          INC ,X
+blocco di controllo del for
+1933 9E FE 01    LDHX 1,SP
+1936 65 01 00    CPHX #0X0100
+1939 25 C8       BNE *-54 ; 1903
+uscita dal for
+
+for(index=0;index<256;index++)
+    { counters[index]=0; }
+
+init del for
+193B 95          TSX
+193C 6F 01       CLR 1,X
+193E 7F          CLR ,X
+corpo del for
+193F 95          TSX
+1940 EE 01       LDX 1,X
+1942 58          LSLX
+1943 9E E6 01    LDA 1,SP
+1946 49          ROLA
+1947 87          PSHA
+1948 8A          PULH
+1949 4F          CLRA
+194A D7 0D 01    STA 3329,X
+194D D7 0D 00    STA 3328,X
+passo del for
+1950 95          TSX
+1951 6C 01       INC 1,X
+1953 26 01       BNE *+3 ; 1956
+1955 7C          INC ,X
+blocco di controllo del for
+1956 9E FE 01    LDHX 1,SP
+1959 65 01 00    CPHX #0X0100
+195C 25 E1       BCS *-29 ; 193F
+
+position=0;
+index=0;
+
+195E 95          TSX
+195F 6F 03       CLR 3,X
+1961 6F 02       CLR 2,X
+1963 6F 01       CLR 1,X
+1965 7F          CLR ,x
+
+***********************************
+
+esempio generato con mathematica
+
+{129, 94, 118, 209, 117, 16, 133, 144, 31, 18, 226, 60, 29, 6, 60, 209, 131, \
+235, 114, 31, 144, 240, 71, 163, 208, 70, 197, 50, 201, 11, 27, 115, 17, 175, \
+210, 191, 11, 188, 8, 229, 254, 172, 252, 148, 52, 136, 40, 219, 211, 61, 56, \
+106, 77, 116, 73, 126, 111, 77, 61, 58, 194, 211, 54, 112, 128, 201, 59, 82, \
+143, 30, 132, 82, 45, 175, 27, 1, 53, 114, 16, 7, 93, 171, 224, 118, 189, 60, \
+13, 206, 183, 157, 169, 243, 193, 147, 140, 78, 248, 195, 19, 58, 162, 189, \
+16, 155, 92, 200, 229, 200, 166, 251, 19, 200, 100, 9, 214, 215, 57, 249, \
+228, 3, 73, 206, 113, 87, 52, 46, 163, 83, 249, 42, 240, 225, 102, 137, 46, \
+134, 199, 45, 18, 213, 74, 121, 109, 27, 65, 148, 108, 109, 244, 93, 139, \
+190, 200, 229, 164, 186, 177, 33, 80, 107, 149, 6, 69, 224, 15, 90, 206, 200, \
+130, 79, 194, 245, 248, 19, 218, 43, 121, 191, 164, 90, 210, 118, 141, 31, \
+21, 90, 222, 35, 157, 126, 103, 99, 17, 245, 36, 214, 106, 12, 127, 18, 214, \
+238, 186, 68, 57, 146, 102, 234, 35, 68, 207, 116, 107, 131, 119, 4, 100, \
+179, 60, 38, 252, 213, 65, 183, 36, 224, 180, 19, 50, 69, 24, 219, 0, 182, \
+95, 58, 183, 79, 180, 223, 244, 26, 16, 233, 197, 44, 188, 91, 5, 74, 82, \
+192, 31, 89, 242, 229, 151, 81, 247, 60, 119, 129, 124, 176, 29, 26, 123, 71, \
+121, 194, 63, 211, 182, 215, 201, 146, 13, 127, 11, 117, 14, 81, 159, 76, \
+229, 208, 193, 57, 127, 234, 65, 5, 8, 126, 118, 47, 98, 113, 248, 56, 182, \
+112, 221, 208, 173, 120, 61, 123, 204, 109, 63, 172, 199, 110, 255, 69, 193, \
+116, 191, 41, 73, 197, 124, 45, 242, 204, 250, 88, 172, 88, 81, 14, 72, 112, \
+65, 237, 149, 180, 71, 241, 129, 228, 64, 84, 123, 161, 210, 2, 197, 125, \
+122, 241, 0, 141, 102, 176, 169, 122, 43, 44, 111, 95, 111, 78, 43, 17, 255, \
+71, 127, 207, 211, 133, 184, 77, 153, 131, 118, 232, 48, 248, 208, 89, 184, \
+113, 87, 175, 181, 213, 252, 130, 22, 16, 179, 193, 26, 1, 17, 255, 89, 36, \
+197, 114, 216, 208, 173, 254, 215, 17, 206, 249, 184, 119, 58, 31, 97, 27, \
+187, 85, 128, 124, 37, 52, 137, 242, 201, 223, 53, 197, 18, 240, 5, 222, 38, \
+73, 183, 57, 5, 194, 219, 252, 159, 169, 102, 173, 74, 63, 191, 109, 135, \
+106, 177, 62, 182, 14, 122, 59, 69, 233, 206, 106, 106, 112, 96, 106, 44, \
+210, 184, 54, 33, 0, 84, 49, 96, 27, 76, 202, 190, 95, 129, 183, 155, 38, \
+148, 43, 65, 43, 152, 99, 102, 101, 70, 35, 229, 7, 158, 28, 56, 92, 151, 99, \
+83, 102, 8, 93, 8, 219, 110, 86, 112, 50, 69, 2, 99, 114, 156, 217, 80, 6, \
+89, 23, 104, 210, 215, 142, 105, 95, 129, 132, 135, 220, 152, 229, 181, 195, \
+37, 108, 146, 221, 42, 209, 20, 126, 23, 178, 152, 85, 252, 61, 141, 239, \
+129, 184, 187, 81, 0, 180, 46, 48, 96, 126, 144, 227, 244, 114, 28, 179, 120, \
+27, 159, 27, 3, 163, 5, 222, 56, 186, 14, 237, 236, 31, 56, 227, 247, 170, \
+233, 61, 255, 243, 20, 44, 136, 97, 48, 171, 24, 220, 254, 106, 41, 241, 203, \
+144, 120, 153, 31, 40, 249, 203, 20, 132, 243, 214, 126, 236, 86, 206, 218, \
+94, 97, 241, 102, 105, 147, 89, 60, 29, 107, 244, 89, 77, 56, 169, 59, 127, \
+178, 236, 174, 246, 178, 34, 100, 39, 108, 32, 238, 81, 62, 136, 221, 193, \
+220, 193, 102, 97, 66, 119, 54, 8, 41, 96, 169, 252, 124, 167, 180, 252, 135, \
+29, 108, 162, 63, 29, 23, 15, 2, 38, 162, 106, 92, 237, 39, 197, 123, 245, \
+156, 133, 99, 86, 195, 75, 27, 160, 27, 137, 53, 214, 217, 221, 46, 98, 117, \
+231, 24, 77, 215, 88, 167, 95, 148, 135, 168, 231, 43, 242, 231, 185, 6, 175, \
+218, 220, 198, 63, 141, 121, 149, 218, 91, 146, 238, 60, 254, 73, 90, 16, 77, \
+137, 131, 38, 236, 141, 201, 119, 238, 241, 64, 109, 73, 87, 155, 196, 31, \
+128, 149, 188, 232, 249, 215, 20, 62, 195, 111, 143, 114, 213, 190, 138, 163, \
+247, 96, 58, 116, 251, 189, 116, 131, 227, 157, 217, 184, 19, 80, 64, 138, \
+150, 58, 166, 236, 124, 21, 135, 77, 106, 170, 224, 186, 255, 59, 226, 81, \
+34, 34, 31, 161, 33, 175, 55, 138, 223, 227, 105, 238, 196, 231, 113, 150, \
+17, 228, 57, 229, 175, 245, 87, 235, 85, 101, 139, 62, 141, 70, 83, 178, 25, \
+52, 233, 74, 75, 82, 48, 63, 167, 79, 26, 184, 100, 91, 217, 109, 97, 165, \
+207, 140, 221, 230, 213, 54, 12, 141, 247, 78, 156, 191, 43, 68, 209, 192, \
+128, 8, 173, 206, 189, 76, 83, 101, 182, 72, 246, 100, 124, 152, 16, 157, \
+253, 73, 196, 221, 20, 182, 111, 59, 70, 215, 26, 68, 164, 129, 49, 162, 64, \
+112, 57, 154, 76, 79, 147, 157, 212, 151, 57, 168, 168, 249, 179, 231, 216, \
+77, 109, 136, 107, 84, 85, 146, 25, 228, 177, 227, 70, 213, 108, 249, 51, \
+229, 210, 119, 24, 134, 20, 126, 30, 200, 180, 206, 199, 87, 45, 82, 231, 87, \
+155, 26, 73, 9, 75, 246, 181, 10, 44, 186, 31, 38, 56, 96, 52, 196, 137, 191, \
+4, 95, 244, 17, 243, 74, 226, 216, 54, 250, 67, 12, 96, 81, 45, 3, 252, 146, \
+33, 202, 117, 102, 220, 132, 196, 111, 240, 4, 82, 171, 154, 206, 170, 47, \
+54, 243, 167, 66, 7, 94, 182, 91, 152, 121, 67, 136, 154, 10, 85, 227, 152, \
+117, 162, 234, 185, 50, 65, 7, 56, 177, 3, 78, 111, 151, 60, 84, 187, 188, \
+11, 12, 171, 59, 40, 170, 4, 80, 163, 107, 250, 240, 230, 24, 216, 122, 95, \
+3, 130, 150, 154, 191, 21, 133, 239, 179, 123, 238, 239, 16, 105, 194, 249, \
+45, 129, 243, 14, 195, 127, 221, 46, 42, 189, 234, 146, 255, 250, 123, 211, \
+48, 117, 103, 168, 15, 33, 220, 229, 226, 137, 41, 197, 163, 162, 66, 63, \
+163, 88, 224, 124, 3, 255, 40, 139, 139, 18, 216, 168, 118, 185, 226, 254, \
+33, 63, 172, 70, 188, 248, 211, 235, 252, 159, 231, 97, 203, 191, 78, 196, \
+151, 30, 13, 121, 131, 171, 76, 38, 99, 111, 238, 89, 129, 2, 44, 237, 111, \
+4, 16, 224, 218, 190, 238, 87, 176, 49, 65, 220, 60, 204, 88, 40, 44, 27, \
+134, 214, 249, 213, 74, 234, 11, 32, 44, 66, 206, 69, 43, 1, 170, 177, 110, \
+183, 183, 40, 149, 25, 167, 92, 78, 123, 62, 211, 144, 134, 113, 20, 210, \
+212, 180, 242, 49, 40, 69, 253, 120, 93, 250, 243, 149, 77, 49, 184, 204, 33, \
+25, 66, 42, 242, 186, 4, 159, 67, 69, 28, 116, 187, 112, 94, 1, 172, 109, \
+215, 156, 157, 26, 152, 177, 252, 97, 163, 65, 65, 175, 29, 225, 50, 25, 96, \
+41, 151, 133, 83, 83, 145, 179, 148, 213, 157, 76, 54, 14, 132, 161, 70, 106, \
+31, 243, 107, 190, 74, 25, 117, 252, 198, 234, 126, 209, 51, 103, 183, 238, \
+89, 226, 221, 34, 140, 155, 62, 152, 252, 19, 226, 12, 78, 49, 135, 103, 106, \
+76, 76, 114, 0, 5, 31, 246, 48, 238, 222, 177, 76, 247, 236, 44, 64, 107, \
+104, 144, 136, 111, 179, 71, 98, 146, 155, 43, 50, 64, 167, 137, 64, 35, 92, \
+249, 41, 98, 174, 91, 201, 44, 146, 111, 245, 160, 14, 222, 249, 9, 16, 57, \
+70, 197, 226, 131, 213, 142, 70, 76, 172, 127, 79, 193, 79, 26, 97, 150, 11, \
+0, 111, 38, 140, 238, 147, 27, 158, 165, 150, 42, 235, 70, 95, 60, 214, 45, \
+148, 107, 244, 218, 105, 89, 172, 189, 158, 72, 2, 220, 92, 96, 42, 110, 202, \
+110, 31, 212, 58, 176, 158, 143, 171, 178, 2, 71, 125, 171, 219, 181, 109, \
+226, 137, 77, 4, 190, 250, 34, 20, 113, 18, 27, 13, 186, 90, 108, 30, 58, 15, \
+110, 68, 200, 181, 140, 3, 6, 100, 133, 40, 100, 34, 129, 118, 254, 250, 98, \
+145, 190, 188, 97, 75, 126, 80, 188, 238, 99, 207, 29, 253, 98, 92, 133, 158, \
+165, 38, 231, 70, 59, 234, 190, 4, 136, 242, 146, 11, 217, 233, 41, 56, 136, \
+138, 105, 23, 75, 191, 12, 242, 253, 115, 89, 190, 84, 28, 211, 49, 98, 27, \
+183, 50, 164, 241, 112, 154, 70, 161, 28, 4, 108, 242, 230, 193, 164, 242, \
+42, 75, 53, 155, 153, 255, 1, 19, 249, 92, 60, 81, 138, 165, 95, 158, 94, \
+198, 33, 55, 210, 185, 152, 161, 96, 233, 69, 202, 215, 189, 207, 15, 36, \
+229, 121, 75, 28, 87, 58, 36, 34, 8, 51, 226, 162, 88, 37, 84, 113, 43, 255, \
+237, 72, 246, 35, 49, 186, 81, 159, 170, 204, 3, 21, 199, 45, 211, 235, 143, \
+132, 64, 83, 173, 103, 236, 175, 220, 28, 116, 107, 173, 205, 167, 17, 16, \
+207, 190, 161, 1, 63, 192, 133, 40, 107, 195, 109, 216, 117, 90, 240, 34, 75, \
+156, 49, 228, 231, 198, 252, 48, 213, 249, 26, 64, 31, 109, 213, 120, 181, \
+118, 201, 225, 223, 18, 97, 223, 159, 87, 125, 11, 173, 90, 161, 132, 229, \
+247, 188, 211, 165, 180, 133, 103, 54, 252, 177, 179, 203, 30, 236, 110, 225, \
+28, 165, 83, 152, 246, 223, 65, 19, 46, 127, 14, 56, 60, 212, 140, 42, 40, \
+78, 126, 14, 247, 202, 62, 228, 180, 5, 88, 220, 120, 217, 249, 121, 132, 2, \
+63, 207, 56, 215, 38, 29, 24, 77, 234, 122, 212, 36, 13, 77, 144, 23, 30, \
+110, 182, 204, 192, 176, 94, 153, 109, 207, 238, 41, 207, 162, 12, 171, 116, \
+41, 78, 130, 147, 105, 123, 236, 199, 137, 202, 221, 172, 101, 128, 20, 9, \
+85, 14, 132, 94, 111, 52, 24, 201, 139, 228, 62, 196, 22, 164, 25, 52, 14, \
+94, 249, 3, 19, 114, 39, 40, 167, 109, 193, 29, 240, 40, 251, 246, 56, 1, \
+249, 188, 102, 248, 110, 209, 181, 56, 67, 182, 104, 172, 9, 253, 9, 104, \
+224, 34, 175, 64, 38, 12, 82, 167, 173, 195, 130, 220, 60, 101, 242, 232, \
+192, 6, 100, 177, 32, 149, 34, 221, 173, 255, 27, 139, 182, 74, 187, 152, 26, \
+236, 123, 166, 44, 225, 199, 220, 25, 6, 10, 159, 82, 43, 202, 47, 64, 248, \
+234, 135, 137, 253, 93, 0, 110, 0, 13, 48, 67, 90, 143, 138, 164, 80, 143, \
+12, 119, 242, 101, 228, 45, 229, 168, 127, 120, 227, 149, 218, 7, 41, 81, \
+148, 228, 1, 191, 110, 152, 156, 144, 168, 10, 61, 60, 80, 235, 18, 196, 95, \
+71, 123, 44, 223, 120, 19, 116, 224, 123, 113, 71, 72, 27, 227, 107, 11, 75, \
+89, 147, 223, 225, 27, 208, 237, 71, 77, 194, 222, 92, 218, 149, 200, 16, \
+119, 127, 192, 167, 211, 211, 216, 52, 161, 21, 224, 4, 30, 130, 202, 217, \
+17, 177, 201, 76, 75, 9, 72, 252, 221, 110, 202, 118, 174, 142, 59, 251, 101, \
+131, 29, 219, 174, 79, 198, 30, 197, 204, 124, 40, 249, 210, 134, 21, 250, \
+65, 69, 46, 149, 191, 13, 139, 141, 17, 156, 184, 251, 38, 214, 145, 13, 205, \
+7, 80, 250, 41, 63, 12, 43, 254, 151, 85, 90, 109, 150, 5, 9, 69, 239, 15, \
+116, 147, 108, 130, 55, 235, 80, 245, 196, 11, 56, 45, 138, 147, 109, 29, \
+229, 247, 231, 215, 92, 180, 80, 117, 13, 243, 206, 49, 241, 142, 143, 219, \
+20, 246, 3, 171, 174, 188, 235, 200, 103, 204, 255, 79, 198, 41, 149, 188, \
+101, 82, 242, 53, 196, 244, 155, 69, 28, 219, 97, 254, 63, 185, 216, 241, \
+172, 7, 164, 184, 136, 149, 184, 86, 50, 90, 62, 34, 11, 150, 238, 111, 30, \
+50, 73, 79, 204, 219, 81, 77, 209, 79, 9, 90, 172, 231, 134, 88, 165, 167, \
+94, 54, 17, 58, 137, 130, 220, 98, 14, 171, 43, 37, 249, 119, 134, 29, 121, \
+81, 189, 152, 183, 187, 246, 217, 102, 1, 18, 235, 10, 205, 26, 170, 204, \
+101, 66, 143, 42, 72, 198, 186, 216, 45, 41, 232, 87, 119, 122, 180, 73, 101, \
+67, 87, 254, 198, 199, 98, 103, 88, 214, 154, 200, 232, 48, 96, 115, 137, 35, \
+8, 122, 172, 93, 109, 206, 12, 27, 23, 193, 66, 83, 21, 124, 116, 43, 37, 86, \
+97, 236, 11, 66, 4, 202, 9, 171, 27, 208, 159, 106, 127, 65, 248, 234, 130, \
+129, 65, 206, 206, 13, 43, 51, 163, 100, 250, 166, 57, 127, 246, 178, 85, \
+107, 172, 51, 147, 231, 190, 52, 207, 239, 162, 238, 237, 203, 176, 137, 218, \
+59, 190, 62, 51, 81, 165, 60, 204, 160, 253, 57, 203, 252, 31, 141, 104, 212, \
+140, 170, 142, 58, 151, 38, 107, 172, 138, 75, 116, 63, 183, 191, 12, 230, \
+205, 66, 250, 238, 249, 12, 44, 121, 126, 216, 64, 124, 56, 73, 113, 117, \
+183, 54, 7, 26, 44, 30, 60, 122, 56, 74, 52, 32, 149, 96, 247, 195, 177, 110, \
+177, 112, 116, 59, 13, 109, 251, 229, 226, 102, 104, 8, 251, 60, 140, 221, 2, \
+46, 110, 241, 175, 121, 103, 226, 76, 165, 121, 198, 181, 175, 21, 254, 226, \
+43, 202, 230, 62, 44, 88, 114, 206, 113, 140, 190, 32, 102, 7, 111, 209, 130, \
+49, 243, 149, 145, 18, 243, 79, 108, 166, 142, 178, 120, 222, 121, 197, 34, \
+243, 7, 231, 158, 146, 115, 60, 161, 218, 33, 35, 69, 229, 116, 132, 194, \
+104, 53, 154, 200, 46, 29, 209, 166, 223, 6, 127, 140, 40, 246, 195, 248, 98, \
+249, 87, 39, 209, 211, 11, 163, 135, 131, 201, 20, 180, 197, 237, 84, 225, \
+185, 41, 111, 227, 13, 204, 246, 13, 36, 69, 110, 228, 219, 249, 193, 212, \
+180, 181, 102, 28, 110, 175, 64, 230, 73, 126, 65, 24, 135, 223, 187, 96, 5, \
+244, 93, 161, 214, 103, 42, 200, 119, 249, 138, 249, 38, 239, 116, 88, 106, \
+200, 53, 16, 197, 30, 11, 131, 106, 68, 141, 92, 251, 254, 146, 3, 67, 5, \
+175, 192, 243, 4, 40, 157, 9, 53, 227, 95, 69, 171, 205, 140, 253, 44, 157, \
+175, 100, 67, 128, 130, 229, 142, 61, 45, 219, 223, 171, 8, 22, 236, 126, \
+167, 203, 216, 92, 44, 136, 152, 194, 173, 29, 176, 177, 206, 147, 226, 244, \
+219, 165, 182, 73, 135, 29, 162, 121, 53, 190, 85, 205, 99, 44, 16, 31, 236, \
+59, 138, 63, 56, 128, 28, 45, 146, 95, 225, 181, 188, 131, 182, 27, 237, 79, \
+58, 196, 254, 255, 203, 129, 103, 194, 89, 218, 10, 156, 34, 235, 147, 226, \
+127, 172, 74, 130, 129, 63, 235, 139, 15, 156, 65, 130, 155, 124, 81, 167, \
+171, 173, 146, 25, 240, 253, 147, 246, 173, 36, 203, 222, 181, 171, 129, 84, \
+174, 36, 100, 210, 208, 254, 51, 42, 117, 7, 143, 58, 18, 159, 190, 27, 27, \
+31, 199, 241, 124, 145, 93, 50, 217, 214, 234, 6, 91, 105, 107, 172, 9, 22, \
+163, 202, 142, 131, 52, 183, 65, 39, 179, 1, 230, 6, 140, 4, 61, 190, 44, \
+102, 181, 134, 17, 19, 109, 208, 190, 141, 199, 85, 2, 193, 118, 95, 32, 94, \
+228, 62, 119, 225, 63, 232, 108, 74, 160, 254, 206, 63, 103, 148, 63, 239, \
+239, 134, 217, 74, 8, 139, 200, 28, 173, 32, 167, 140, 6, 103, 175, 115, 205, \
+22, 132, 50, 208, 243, 220, 219, 183, 36, 106, 99, 28, 161, 222, 188, 146, \
+241, 92, 231, 224, 213, 164, 74, 0, 214, 34, 156, 82, 143, 232, 34, 162, 240, \
+152, 56, 13, 246, 67, 121, 130, 175, 213, 193, 130, 82, 219, 143, 126, 209, \
+157, 166, 142, 158, 169, 142, 209, 246, 176, 234, 131, 233, 247, 59, 74, 9, \
+30, 50, 210, 93, 215, 171, 77, 111, 89, 252, 67, 65, 0, 60, 148, 82, 89, 108, \
+110, 232, 102, 245, 156, 87, 108, 226, 59, 162, 33, 238, 246, 79, 243, 98, \
+219, 143, 100, 211, 128, 105, 151, 71, 139, 182, 56, 69, 190, 13, 97, 207, \
+120, 207, 65, 127, 244, 90, 139, 114, 230, 125, 76, 24, 238, 58, 18, 148, 52, \
+48, 57, 0, 149, 96, 250, 127, 166, 199, 177, 126, 13, 36, 255, 67, 120, 136, \
+108, 7, 115, 146, 200, 11, 80, 151, 244, 27, 219, 69, 98, 145, 135, 93, 245, \
+97, 56, 243, 138, 79, 219, 61, 67, 47, 186, 169, 180, 169, 38, 126, 140, 22, \
+252, 28, 167, 157, 124, 133, 167, 53, 134, 79, 200, 154, 13, 36, 4, 88, 66, \
+48, 117, 141, 188, 114, 52, 249, 70, 94, 244, 92, 103, 4, 136, 40, 169, 236, \
+236, 124, 70, 110, 28, 217, 192, 97, 88, 94, 55, 176, 153, 151, 160, 155, \
+119, 74, 208, 181, 29, 166, 74, 197, 58, 148, 180, 80, 6, 192, 168, 2, 95, \
+14, 33, 3, 177, 150, 2, 151, 128, 26, 11, 61, 33, 127, 3, 41, 50, 102, 191, \
+59, 87, 83, 231, 213, 229, 69, 163, 26, 27, 248, 207, 179, 149, 89, 78, 100, \
+67, 244, 37, 204, 97, 53, 223, 54, 85, 207, 154, 17, 246, 212, 79, 155, 175, \
+242, 3, 25, 155, 171, 196, 25, 161, 234, 27, 37, 173, 170, 0, 91, 157, 111, \
+136, 111, 48, 133, 198, 23, 87, 17, 171, 2, 221, 146, 77, 130, 2, 53, 203, \
+68, 164, 65, 213, 18, 231, 77}
+
+e riformattato per importazione
+
+〈x8,x1〉;〈x5,xE〉;〈x7,x6〉;〈xD,x1〉;〈x7,x5〉;〈x1,x0〉;〈x8,x5〉;〈x9,x0〉;〈x1,xF〉;〈x1,x2〉;〈xE,x2〉;〈x3,xC〉;〈x1,xD〉;〈x0,x6〉;〈x3,xC〉;〈xD,x1〉;
+〈x8,x3〉;〈xE,xB〉;〈x7,x2〉;〈x1,xF〉;〈x9,x0〉;〈xF,x0〉;〈x4,x7〉;〈xA,x3〉;〈xD,x0〉;〈x4,x6〉;〈xC,x5〉;〈x3,x2〉;〈xC,x9〉;〈x0,xB〉;〈x1,xB〉;〈x7,x3〉;
+〈x1,x1〉;〈xA,xF〉;〈xD,x2〉;〈xB,xF〉;〈x0,xB〉;〈xB,xC〉;〈x0,x8〉;〈xE,x5〉;〈xF,xE〉;〈xA,xC〉;〈xF,xC〉;〈x9,x4〉;〈x3,x4〉;〈x8,x8〉;〈x2,x8〉;〈xD,xB〉;
+〈xD,x3〉;〈x3,xD〉;〈x3,x8〉;〈x6,xA〉;〈x4,xD〉;〈x7,x4〉;〈x4,x9〉;〈x7,xE〉;〈x6,xF〉;〈x4,xD〉;〈x3,xD〉;〈x3,xA〉;〈xC,x2〉;〈xD,x3〉;〈x3,x6〉;〈x7,x0〉;
+〈x8,x0〉;〈xC,x9〉;〈x3,xB〉;〈x5,x2〉;〈x8,xF〉;〈x1,xE〉;〈x8,x4〉;〈x5,x2〉;〈x2,xD〉;〈xA,xF〉;〈x1,xB〉;〈x0,x1〉;〈x3,x5〉;〈x7,x2〉;〈x1,x0〉;〈x0,x7〉;
+〈x5,xD〉;〈xA,xB〉;〈xE,x0〉;〈x7,x6〉;〈xB,xD〉;〈x3,xC〉;〈x0,xD〉;〈xC,xE〉;〈xB,x7〉;〈x9,xD〉;〈xA,x9〉;〈xF,x3〉;〈xC,x1〉;〈x9,x3〉;〈x8,xC〉;〈x4,xE〉;
+〈xF,x8〉;〈xC,x3〉;〈x1,x3〉;〈x3,xA〉;〈xA,x2〉;〈xB,xD〉;〈x1,x0〉;〈x9,xB〉;〈x5,xC〉;〈xC,x8〉;〈xE,x5〉;〈xC,x8〉;〈xA,x6〉;〈xF,xB〉;〈x1,x3〉;〈xC,x8〉;
+〈x6,x4〉;〈x0,x9〉;〈xD,x6〉;〈xD,x7〉;〈x3,x9〉;〈xF,x9〉;〈xE,x4〉;〈x0,x3〉;〈x4,x9〉;〈xC,xE〉;〈x7,x1〉;〈x5,x7〉;〈x3,x4〉;〈x2,xE〉;〈xA,x3〉;〈x5,x3〉;
+〈xF,x9〉;〈x2,xA〉;〈xF,x0〉;〈xE,x1〉;〈x6,x6〉;〈x8,x9〉;〈x2,xE〉;〈x8,x6〉;〈xC,x7〉;〈x2,xD〉;〈x1,x2〉;〈xD,x5〉;〈x4,xA〉;〈x7,x9〉;〈x6,xD〉;〈x1,xB〉;
+〈x4,x1〉;〈x9,x4〉;〈x6,xC〉;〈x6,xD〉;〈xF,x4〉;〈x5,xD〉;〈x8,xB〉;〈xB,xE〉;〈xC,x8〉;〈xE,x5〉;〈xA,x4〉;〈xB,xA〉;〈xB,x1〉;〈x2,x1〉;〈x5,x0〉;〈x6,xB〉;
+〈x9,x5〉;〈x0,x6〉;〈x4,x5〉;〈xE,x0〉;〈x0,xF〉;〈x5,xA〉;〈xC,xE〉;〈xC,x8〉;〈x8,x2〉;〈x4,xF〉;〈xC,x2〉;〈xF,x5〉;〈xF,x8〉;〈x1,x3〉;〈xD,xA〉;〈x2,xB〉;
+〈x7,x9〉;〈xB,xF〉;〈xA,x4〉;〈x5,xA〉;〈xD,x2〉;〈x7,x6〉;〈x8,xD〉;〈x1,xF〉;〈x1,x5〉;〈x5,xA〉;〈xD,xE〉;〈x2,x3〉;〈x9,xD〉;〈x7,xE〉;〈x6,x7〉;〈x6,x3〉;
+〈x1,x1〉;〈xF,x5〉;〈x2,x4〉;〈xD,x6〉;〈x6,xA〉;〈x0,xC〉;〈x7,xF〉;〈x1,x2〉;〈xD,x6〉;〈xE,xE〉;〈xB,xA〉;〈x4,x4〉;〈x3,x9〉;〈x9,x2〉;〈x6,x6〉;〈xE,xA〉;
+〈x2,x3〉;〈x4,x4〉;〈xC,xF〉;〈x7,x4〉;〈x6,xB〉;〈x8,x3〉;〈x7,x7〉;〈x0,x4〉;〈x6,x4〉;〈xB,x3〉;〈x3,xC〉;〈x2,x6〉;〈xF,xC〉;〈xD,x5〉;〈x4,x1〉;〈xB,x7〉;
+〈x2,x4〉;〈xE,x0〉;〈xB,x4〉;〈x1,x3〉;〈x3,x2〉;〈x4,x5〉;〈x1,x8〉;〈xD,xB〉;〈x0,x0〉;〈xB,x6〉;〈x5,xF〉;〈x3,xA〉;〈xB,x7〉;〈x4,xF〉;〈xB,x4〉;〈xD,xF〉;
+〈xF,x4〉;〈x1,xA〉;〈x1,x0〉;〈xE,x9〉;〈xC,x5〉;〈x2,xC〉;〈xB,xC〉;〈x5,xB〉;〈x0,x5〉;〈x4,xA〉;〈x5,x2〉;〈xC,x0〉;〈x1,xF〉;〈x5,x9〉;〈xF,x2〉;〈xE,x5〉;
+
+〈x9,x7〉;〈x5,x1〉;〈xF,x7〉;〈x3,xC〉;〈x7,x7〉;〈x8,x1〉;〈x7,xC〉;〈xB,x0〉;〈x1,xD〉;〈x1,xA〉;〈x7,xB〉;〈x4,x7〉;〈x7,x9〉;〈xC,x2〉;〈x3,xF〉;〈xD,x3〉;
+〈xB,x6〉;〈xD,x7〉;〈xC,x9〉;〈x9,x2〉;〈x0,xD〉;〈x7,xF〉;〈x0,xB〉;〈x7,x5〉;〈x0,xE〉;〈x5,x1〉;〈x9,xF〉;〈x4,xC〉;〈xE,x5〉;〈xD,x0〉;〈xC,x1〉;〈x3,x9〉;
+〈x7,xF〉;〈xE,xA〉;〈x4,x1〉;〈x0,x5〉;〈x0,x8〉;〈x7,xE〉;〈x7,x6〉;〈x2,xF〉;〈x6,x2〉;〈x7,x1〉;〈xF,x8〉;〈x3,x8〉;〈xB,x6〉;〈x7,x0〉;〈xD,xD〉;〈xD,x0〉;
+〈xA,xD〉;〈x7,x8〉;〈x3,xD〉;〈x7,xB〉;〈xC,xC〉;〈x6,xD〉;〈x3,xF〉;〈xA,xC〉;〈xC,x7〉;〈x6,xE〉;〈xF,xF〉;〈x4,x5〉;〈xC,x1〉;〈x7,x4〉;〈xB,xF〉;〈x2,x9〉;
+〈x4,x9〉;〈xC,x5〉;〈x7,xC〉;〈x2,xD〉;〈xF,x2〉;〈xC,xC〉;〈xF,xA〉;〈x5,x8〉;〈xA,xC〉;〈x5,x8〉;〈x5,x1〉;〈x0,xE〉;〈x4,x8〉;〈x7,x0〉;〈x4,x1〉;〈xE,xD〉;
+〈x9,x5〉;〈xB,x4〉;〈x4,x7〉;〈xF,x1〉;〈x8,x1〉;〈xE,x4〉;〈x4,x0〉;〈x5,x4〉;〈x7,xB〉;〈xA,x1〉;〈xD,x2〉;〈x0,x2〉;〈xC,x5〉;〈x7,xD〉;〈x7,xA〉;〈xF,x1〉;
+〈x0,x0〉;〈x8,xD〉;〈x6,x6〉;〈xB,x0〉;〈xA,x9〉;〈x7,xA〉;〈x2,xB〉;〈x2,xC〉;〈x6,xF〉;〈x5,xF〉;〈x6,xF〉;〈x4,xE〉;〈x2,xB〉;〈x1,x1〉;〈xF,xF〉;〈x4,x7〉;
+〈x7,xF〉;〈xC,xF〉;〈xD,x3〉;〈x8,x5〉;〈xB,x8〉;〈x4,xD〉;〈x9,x9〉;〈x8,x3〉;〈x7,x6〉;〈xE,x8〉;〈x3,x0〉;〈xF,x8〉;〈xD,x0〉;〈x5,x9〉;〈xB,x8〉;〈x7,x1〉;
+〈x5,x7〉;〈xA,xF〉;〈xB,x5〉;〈xD,x5〉;〈xF,xC〉;〈x8,x2〉;〈x1,x6〉;〈x1,x0〉;〈xB,x3〉;〈xC,x1〉;〈x1,xA〉;〈x0,x1〉;〈x1,x1〉;〈xF,xF〉;〈x5,x9〉;〈x2,x4〉;
+〈xC,x5〉;〈x7,x2〉;〈xD,x8〉;〈xD,x0〉;〈xA,xD〉;〈xF,xE〉;〈xD,x7〉;〈x1,x1〉;〈xC,xE〉;〈xF,x9〉;〈xB,x8〉;〈x7,x7〉;〈x3,xA〉;〈x1,xF〉;〈x6,x1〉;〈x1,xB〉;
+〈xB,xB〉;〈x5,x5〉;〈x8,x0〉;〈x7,xC〉;〈x2,x5〉;〈x3,x4〉;〈x8,x9〉;〈xF,x2〉;〈xC,x9〉;〈xD,xF〉;〈x3,x5〉;〈xC,x5〉;〈x1,x2〉;〈xF,x0〉;〈x0,x5〉;〈xD,xE〉;
+〈x2,x6〉;〈x4,x9〉;〈xB,x7〉;〈x3,x9〉;〈x0,x5〉;〈xC,x2〉;〈xD,xB〉;〈xF,xC〉;〈x9,xF〉;〈xA,x9〉;〈x6,x6〉;〈xA,xD〉;〈x4,xA〉;〈x3,xF〉;〈xB,xF〉;〈x6,xD〉;
+〈x8,x7〉;〈x6,xA〉;〈xB,x1〉;〈x3,xE〉;〈xB,x6〉;〈x0,xE〉;〈x7,xA〉;〈x3,xB〉;〈x4,x5〉;〈xE,x9〉;〈xC,xE〉;〈x6,xA〉;〈x6,xA〉;〈x7,x0〉;〈x6,x0〉;〈x6,xA〉;
+〈x2,xC〉;〈xD,x2〉;〈xB,x8〉;〈x3,x6〉;〈x2,x1〉;〈x0,x0〉;〈x5,x4〉;〈x3,x1〉;〈x6,x0〉;〈x1,xB〉;〈x4,xC〉;〈xC,xA〉;〈xB,xE〉;〈x5,xF〉;〈x8,x1〉;〈xB,x7〉;
+〈x9,xB〉;〈x2,x6〉;〈x9,x4〉;〈x2,xB〉;〈x4,x1〉;〈x2,xB〉;〈x9,x8〉;〈x6,x3〉;〈x6,x6〉;〈x6,x5〉;〈x4,x6〉;〈x2,x3〉;〈xE,x5〉;〈x0,x7〉;〈x9,xE〉;〈x1,xC〉;
+〈x3,x8〉;〈x5,xC〉;〈x9,x7〉;〈x6,x3〉;〈x5,x3〉;〈x6,x6〉;〈x0,x8〉;〈x5,xD〉;〈x0,x8〉;〈xD,xB〉;〈x6,xE〉;〈x5,x6〉;〈x7,x0〉;〈x3,x2〉;〈x4,x5〉;〈x0,x2〉;
+
+〈x6,x3〉;〈x7,x2〉;〈x9,xC〉;〈xD,x9〉;〈x5,x0〉;〈x0,x6〉;〈x5,x9〉;〈x1,x7〉;〈x6,x8〉;〈xD,x2〉;〈xD,x7〉;〈x8,xE〉;〈x6,x9〉;〈x5,xF〉;〈x8,x1〉;〈x8,x4〉;
+〈x8,x7〉;〈xD,xC〉;〈x9,x8〉;〈xE,x5〉;〈xB,x5〉;〈xC,x3〉;〈x2,x5〉;〈x6,xC〉;〈x9,x2〉;〈xD,xD〉;〈x2,xA〉;〈xD,x1〉;〈x1,x4〉;〈x7,xE〉;〈x1,x7〉;〈xB,x2〉;
+〈x9,x8〉;〈x5,x5〉;〈xF,xC〉;〈x3,xD〉;〈x8,xD〉;〈xE,xF〉;〈x8,x1〉;〈xB,x8〉;〈xB,xB〉;〈x5,x1〉;〈x0,x0〉;〈xB,x4〉;〈x2,xE〉;〈x3,x0〉;〈x6,x0〉;〈x7,xE〉;
+〈x9,x0〉;〈xE,x3〉;〈xF,x4〉;〈x7,x2〉;〈x1,xC〉;〈xB,x3〉;〈x7,x8〉;〈x1,xB〉;〈x9,xF〉;〈x1,xB〉;〈x0,x3〉;〈xA,x3〉;〈x0,x5〉;〈xD,xE〉;〈x3,x8〉;〈xB,xA〉;
+〈x0,xE〉;〈xE,xD〉;〈xE,xC〉;〈x1,xF〉;〈x3,x8〉;〈xE,x3〉;〈xF,x7〉;〈xA,xA〉;〈xE,x9〉;〈x3,xD〉;〈xF,xF〉;〈xF,x3〉;〈x1,x4〉;〈x2,xC〉;〈x8,x8〉;〈x6,x1〉;
+〈x3,x0〉;〈xA,xB〉;〈x1,x8〉;〈xD,xC〉;〈xF,xE〉;〈x6,xA〉;〈x2,x9〉;〈xF,x1〉;〈xC,xB〉;〈x9,x0〉;〈x7,x8〉;〈x9,x9〉;〈x1,xF〉;〈x2,x8〉;〈xF,x9〉;〈xC,xB〉;
+〈x1,x4〉;〈x8,x4〉;〈xF,x3〉;〈xD,x6〉;〈x7,xE〉;〈xE,xC〉;〈x5,x6〉;〈xC,xE〉;〈xD,xA〉;〈x5,xE〉;〈x6,x1〉;〈xF,x1〉;〈x6,x6〉;〈x6,x9〉;〈x9,x3〉;〈x5,x9〉;
+〈x3,xC〉;〈x1,xD〉;〈x6,xB〉;〈xF,x4〉;〈x5,x9〉;〈x4,xD〉;〈x3,x8〉;〈xA,x9〉;〈x3,xB〉;〈x7,xF〉;〈xB,x2〉;〈xE,xC〉;〈xA,xE〉;〈xF,x6〉;〈xB,x2〉;〈x2,x2〉;
+〈x6,x4〉;〈x2,x7〉;〈x6,xC〉;〈x2,x0〉;〈xE,xE〉;〈x5,x1〉;〈x3,xE〉;〈x8,x8〉;〈xD,xD〉;〈xC,x1〉;〈xD,xC〉;〈xC,x1〉;〈x6,x6〉;〈x6,x1〉;〈x4,x2〉;〈x7,x7〉;
+〈x3,x6〉;〈x0,x8〉;〈x2,x9〉;〈x6,x0〉;〈xA,x9〉;〈xF,xC〉;〈x7,xC〉;〈xA,x7〉;〈xB,x4〉;〈xF,xC〉;〈x8,x7〉;〈x1,xD〉;〈x6,xC〉;〈xA,x2〉;〈x3,xF〉;〈x1,xD〉;
+〈x1,x7〉;〈x0,xF〉;〈x0,x2〉;〈x2,x6〉;〈xA,x2〉;〈x6,xA〉;〈x5,xC〉;〈xE,xD〉;〈x2,x7〉;〈xC,x5〉;〈x7,xB〉;〈xF,x5〉;〈x9,xC〉;〈x8,x5〉;〈x6,x3〉;〈x5,x6〉;
+〈xC,x3〉;〈x4,xB〉;〈x1,xB〉;〈xA,x0〉;〈x1,xB〉;〈x8,x9〉;〈x3,x5〉;〈xD,x6〉;〈xD,x9〉;〈xD,xD〉;〈x2,xE〉;〈x6,x2〉;〈x7,x5〉;〈xE,x7〉;〈x1,x8〉;〈x4,xD〉;
+〈xD,x7〉;〈x5,x8〉;〈xA,x7〉;〈x5,xF〉;〈x9,x4〉;〈x8,x7〉;〈xA,x8〉;〈xE,x7〉;〈x2,xB〉;〈xF,x2〉;〈xE,x7〉;〈xB,x9〉;〈x0,x6〉;〈xA,xF〉;〈xD,xA〉;〈xD,xC〉;
+〈xC,x6〉;〈x3,xF〉;〈x8,xD〉;〈x7,x9〉;〈x9,x5〉;〈xD,xA〉;〈x5,xB〉;〈x9,x2〉;〈xE,xE〉;〈x3,xC〉;〈xF,xE〉;〈x4,x9〉;〈x5,xA〉;〈x1,x0〉;〈x4,xD〉;〈x8,x9〉;
+〈x8,x3〉;〈x2,x6〉;〈xE,xC〉;〈x8,xD〉;〈xC,x9〉;〈x7,x7〉;〈xE,xE〉;〈xF,x1〉;〈x4,x0〉;〈x6,xD〉;〈x4,x9〉;〈x5,x7〉;〈x9,xB〉;〈xC,x4〉;〈x1,xF〉;〈x8,x0〉;
+〈x9,x5〉;〈xB,xC〉;〈xE,x8〉;〈xF,x9〉;〈xD,x7〉;〈x1,x4〉;〈x3,xE〉;〈xC,x3〉;〈x6,xF〉;〈x8,xF〉;〈x7,x2〉;〈xD,x5〉;〈xB,xE〉;〈x8,xA〉;〈xA,x3〉;〈xF,x7〉;
+
+〈x6,x0〉;〈x3,xA〉;〈x7,x4〉;〈xF,xB〉;〈xB,xD〉;〈x7,x4〉;〈x8,x3〉;〈xE,x3〉;〈x9,xD〉;〈xD,x9〉;〈xB,x8〉;〈x1,x3〉;〈x5,x0〉;〈x4,x0〉;〈x8,xA〉;〈x9,x6〉;
+〈x3,xA〉;〈xA,x6〉;〈xE,xC〉;〈x7,xC〉;〈x1,x5〉;〈x8,x7〉;〈x4,xD〉;〈x6,xA〉;〈xA,xA〉;〈xE,x0〉;〈xB,xA〉;〈xF,xF〉;〈x3,xB〉;〈xE,x2〉;〈x5,x1〉;〈x2,x2〉;
+〈x2,x2〉;〈x1,xF〉;〈xA,x1〉;〈x2,x1〉;〈xA,xF〉;〈x3,x7〉;〈x8,xA〉;〈xD,xF〉;〈xE,x3〉;〈x6,x9〉;〈xE,xE〉;〈xC,x4〉;〈xE,x7〉;〈x7,x1〉;〈x9,x6〉;〈x1,x1〉;
+〈xE,x4〉;〈x3,x9〉;〈xE,x5〉;〈xA,xF〉;〈xF,x5〉;〈x5,x7〉;〈xE,xB〉;〈x5,x5〉;〈x6,x5〉;〈x8,xB〉;〈x3,xE〉;〈x8,xD〉;〈x4,x6〉;〈x5,x3〉;〈xB,x2〉;〈x1,x9〉;
+〈x3,x4〉;〈xE,x9〉;〈x4,xA〉;〈x4,xB〉;〈x5,x2〉;〈x3,x0〉;〈x3,xF〉;〈xA,x7〉;〈x4,xF〉;〈x1,xA〉;〈xB,x8〉;〈x6,x4〉;〈x5,xB〉;〈xD,x9〉;〈x6,xD〉;〈x6,x1〉;
+〈xA,x5〉;〈xC,xF〉;〈x8,xC〉;〈xD,xD〉;〈xE,x6〉;〈xD,x5〉;〈x3,x6〉;〈x0,xC〉;〈x8,xD〉;〈xF,x7〉;〈x4,xE〉;〈x9,xC〉;〈xB,xF〉;〈x2,xB〉;〈x4,x4〉;〈xD,x1〉;
+〈xC,x0〉;〈x8,x0〉;〈x0,x8〉;〈xA,xD〉;〈xC,xE〉;〈xB,xD〉;〈x4,xC〉;〈x5,x3〉;〈x6,x5〉;〈xB,x6〉;〈x4,x8〉;〈xF,x6〉;〈x6,x4〉;〈x7,xC〉;〈x9,x8〉;〈x1,x0〉;
+〈x9,xD〉;〈xF,xD〉;〈x4,x9〉;〈xC,x4〉;〈xD,xD〉;〈x1,x4〉;〈xB,x6〉;〈x6,xF〉;〈x3,xB〉;〈x4,x6〉;〈xD,x7〉;〈x1,xA〉;〈x4,x4〉;〈xA,x4〉;〈x8,x1〉;〈x3,x1〉;
+〈xA,x2〉;〈x4,x0〉;〈x7,x0〉;〈x3,x9〉;〈x9,xA〉;〈x4,xC〉;〈x4,xF〉;〈x9,x3〉;〈x9,xD〉;〈xD,x4〉;〈x9,x7〉;〈x3,x9〉;〈xA,x8〉;〈xA,x8〉;〈xF,x9〉;〈xB,x3〉;
+〈xE,x7〉;〈xD,x8〉;〈x4,xD〉;〈x6,xD〉;〈x8,x8〉;〈x6,xB〉;〈x5,x4〉;〈x5,x5〉;〈x9,x2〉;〈x1,x9〉;〈xE,x4〉;〈xB,x1〉;〈xE,x3〉;〈x4,x6〉;〈xD,x5〉;〈x6,xC〉;
+〈xF,x9〉;〈x3,x3〉;〈xE,x5〉;〈xD,x2〉;〈x7,x7〉;〈x1,x8〉;〈x8,x6〉;〈x1,x4〉;〈x7,xE〉;〈x1,xE〉;〈xC,x8〉;〈xB,x4〉;〈xC,xE〉;〈xC,x7〉;〈x5,x7〉;〈x2,xD〉;
+〈x5,x2〉;〈xE,x7〉;〈x5,x7〉;〈x9,xB〉;〈x1,xA〉;〈x4,x9〉;〈x0,x9〉;〈x4,xB〉;〈xF,x6〉;〈xB,x5〉;〈x0,xA〉;〈x2,xC〉;〈xB,xA〉;〈x1,xF〉;〈x2,x6〉;〈x3,x8〉;
+〈x6,x0〉;〈x3,x4〉;〈xC,x4〉;〈x8,x9〉;〈xB,xF〉;〈x0,x4〉;〈x5,xF〉;〈xF,x4〉;〈x1,x1〉;〈xF,x3〉;〈x4,xA〉;〈xE,x2〉;〈xD,x8〉;〈x3,x6〉;〈xF,xA〉;〈x4,x3〉;
+〈x0,xC〉;〈x6,x0〉;〈x5,x1〉;〈x2,xD〉;〈x0,x3〉;〈xF,xC〉;〈x9,x2〉;〈x2,x1〉;〈xC,xA〉;〈x7,x5〉;〈x6,x6〉;〈xD,xC〉;〈x8,x4〉;〈xC,x4〉;〈x6,xF〉;〈xF,x0〉;
+〈x0,x4〉;〈x5,x2〉;〈xA,xB〉;〈x9,xA〉;〈xC,xE〉;〈xA,xA〉;〈x2,xF〉;〈x3,x6〉;〈xF,x3〉;〈xA,x7〉;〈x4,x2〉;〈x0,x7〉;〈x5,xE〉;〈xB,x6〉;〈x5,xB〉;〈x9,x8〉;
+〈x7,x9〉;〈x4,x3〉;〈x8,x8〉;〈x9,xA〉;〈x0,xA〉;〈x5,x5〉;〈xE,x3〉;〈x9,x8〉;〈x7,x5〉;〈xA,x2〉;〈xE,xA〉;〈xB,x9〉;〈x3,x2〉;〈x4,x1〉;〈x0,x7〉;〈x3,x8〉;
+
+〈xB,x1〉;〈x0,x3〉;〈x4,xE〉;〈x6,xF〉;〈x9,x7〉;〈x3,xC〉;〈x5,x4〉;〈xB,xB〉;〈xB,xC〉;〈x0,xB〉;〈x0,xC〉;〈xA,xB〉;〈x3,xB〉;〈x2,x8〉;〈xA,xA〉;〈x0,x4〉;
+〈x5,x0〉;〈xA,x3〉;〈x6,xB〉;〈xF,xA〉;〈xF,x0〉;〈xE,x6〉;〈x1,x8〉;〈xD,x8〉;〈x7,xA〉;〈x5,xF〉;〈x0,x3〉;〈x8,x2〉;〈x9,x6〉;〈x9,xA〉;〈xB,xF〉;〈x1,x5〉;
+〈x8,x5〉;〈xE,xF〉;〈xB,x3〉;〈x7,xB〉;〈xE,xE〉;〈xE,xF〉;〈x1,x0〉;〈x6,x9〉;〈xC,x2〉;〈xF,x9〉;〈x2,xD〉;〈x8,x1〉;〈xF,x3〉;〈x0,xE〉;〈xC,x3〉;〈x7,xF〉;
+〈xD,xD〉;〈x2,xE〉;〈x2,xA〉;〈xB,xD〉;〈xE,xA〉;〈x9,x2〉;〈xF,xF〉;〈xF,xA〉;〈x7,xB〉;〈xD,x3〉;〈x3,x0〉;〈x7,x5〉;〈x6,x7〉;〈xA,x8〉;〈x0,xF〉;〈x2,x1〉;
+〈xD,xC〉;〈xE,x5〉;〈xE,x2〉;〈x8,x9〉;〈x2,x9〉;〈xC,x5〉;〈xA,x3〉;〈xA,x2〉;〈x4,x2〉;〈x3,xF〉;〈xA,x3〉;〈x5,x8〉;〈xE,x0〉;〈x7,xC〉;〈x0,x3〉;〈xF,xF〉;
+〈x2,x8〉;〈x8,xB〉;〈x8,xB〉;〈x1,x2〉;〈xD,x8〉;〈xA,x8〉;〈x7,x6〉;〈xB,x9〉;〈xE,x2〉;〈xF,xE〉;〈x2,x1〉;〈x3,xF〉;〈xA,xC〉;〈x4,x6〉;〈xB,xC〉;〈xF,x8〉;
+〈xD,x3〉;〈xE,xB〉;〈xF,xC〉;〈x9,xF〉;〈xE,x7〉;〈x6,x1〉;〈xC,xB〉;〈xB,xF〉;〈x4,xE〉;〈xC,x4〉;〈x9,x7〉;〈x1,xE〉;〈x0,xD〉;〈x7,x9〉;〈x8,x3〉;〈xA,xB〉;
+〈x4,xC〉;〈x2,x6〉;〈x6,x3〉;〈x6,xF〉;〈xE,xE〉;〈x5,x9〉;〈x8,x1〉;〈x0,x2〉;〈x2,xC〉;〈xE,xD〉;〈x6,xF〉;〈x0,x4〉;〈x1,x0〉;〈xE,x0〉;〈xD,xA〉;〈xB,xE〉;
+〈xE,xE〉;〈x5,x7〉;〈xB,x0〉;〈x3,x1〉;〈x4,x1〉;〈xD,xC〉;〈x3,xC〉;〈xC,xC〉;〈x5,x8〉;〈x2,x8〉;〈x2,xC〉;〈x1,xB〉;〈x8,x6〉;〈xD,x6〉;〈xF,x9〉;〈xD,x5〉;
+〈x4,xA〉;〈xE,xA〉;〈x0,xB〉;〈x2,x0〉;〈x2,xC〉;〈x4,x2〉;〈xC,xE〉;〈x4,x5〉;〈x2,xB〉;〈x0,x1〉;〈xA,xA〉;〈xB,x1〉;〈x6,xE〉;〈xB,x7〉;〈xB,x7〉;〈x2,x8〉;
+〈x9,x5〉;〈x1,x9〉;〈xA,x7〉;〈x5,xC〉;〈x4,xE〉;〈x7,xB〉;〈x3,xE〉;〈xD,x3〉;〈x9,x0〉;〈x8,x6〉;〈x7,x1〉;〈x1,x4〉;〈xD,x2〉;〈xD,x4〉;〈xB,x4〉;〈xF,x2〉;
+〈x3,x1〉;〈x2,x8〉;〈x4,x5〉;〈xF,xD〉;〈x7,x8〉;〈x5,xD〉;〈xF,xA〉;〈xF,x3〉;〈x9,x5〉;〈x4,xD〉;〈x3,x1〉;〈xB,x8〉;〈xC,xC〉;〈x2,x1〉;〈x1,x9〉;〈x4,x2〉;
+〈x2,xA〉;〈xF,x2〉;〈xB,xA〉;〈x0,x4〉;〈x9,xF〉;〈x4,x3〉;〈x4,x5〉;〈x1,xC〉;〈x7,x4〉;〈xB,xB〉;〈x7,x0〉;〈x5,xE〉;〈x0,x1〉;〈xA,xC〉;〈x6,xD〉;〈xD,x7〉;
+〈x9,xC〉;〈x9,xD〉;〈x1,xA〉;〈x9,x8〉;〈xB,x1〉;〈xF,xC〉;〈x6,x1〉;〈xA,x3〉;〈x4,x1〉;〈x4,x1〉;〈xA,xF〉;〈x1,xD〉;〈xE,x1〉;〈x3,x2〉;〈x1,x9〉;〈x6,x0〉;
+〈x2,x9〉;〈x9,x7〉;〈x8,x5〉;〈x5,x3〉;〈x5,x3〉;〈x9,x1〉;〈xB,x3〉;〈x9,x4〉;〈xD,x5〉;〈x9,xD〉;〈x4,xC〉;〈x3,x6〉;〈x0,xE〉;〈x8,x4〉;〈xA,x1〉;〈x4,x6〉;
+〈x6,xA〉;〈x1,xF〉;〈xF,x3〉;〈x6,xB〉;〈xB,xE〉;〈x4,xA〉;〈x1,x9〉;〈x7,x5〉;〈xF,xC〉;〈xC,x6〉;〈xE,xA〉;〈x7,xE〉;〈xD,x1〉;〈x3,x3〉;〈x6,x7〉;〈xB,x7〉;
+
+〈xE,xE〉;〈x5,x9〉;〈xE,x2〉;〈xD,xD〉;〈x2,x2〉;〈x8,xC〉;〈x9,xB〉;〈x3,xE〉;〈x9,x8〉;〈xF,xC〉;〈x1,x3〉;〈xE,x2〉;〈x0,xC〉;〈x4,xE〉;〈x3,x1〉;〈x8,x7〉;
+〈x6,x7〉;〈x6,xA〉;〈x4,xC〉;〈x4,xC〉;〈x7,x2〉;〈x0,x0〉;〈x0,x5〉;〈x1,xF〉;〈xF,x6〉;〈x3,x0〉;〈xE,xE〉;〈xD,xE〉;〈xB,x1〉;〈x4,xC〉;〈xF,x7〉;〈xE,xC〉;
+〈x2,xC〉;〈x4,x0〉;〈x6,xB〉;〈x6,x8〉;〈x9,x0〉;〈x8,x8〉;〈x6,xF〉;〈xB,x3〉;〈x4,x7〉;〈x6,x2〉;〈x9,x2〉;〈x9,xB〉;〈x2,xB〉;〈x3,x2〉;〈x4,x0〉;〈xA,x7〉;
+〈x8,x9〉;〈x4,x0〉;〈x2,x3〉;〈x5,xC〉;〈xF,x9〉;〈x2,x9〉;〈x6,x2〉;〈xA,xE〉;〈x5,xB〉;〈xC,x9〉;〈x2,xC〉;〈x9,x2〉;〈x6,xF〉;〈xF,x5〉;〈xA,x0〉;〈x0,xE〉;
+〈xD,xE〉;〈xF,x9〉;〈x0,x9〉;〈x1,x0〉;〈x3,x9〉;〈x4,x6〉;〈xC,x5〉;〈xE,x2〉;〈x8,x3〉;〈xD,x5〉;〈x8,xE〉;〈x4,x6〉;〈x4,xC〉;〈xA,xC〉;〈x7,xF〉;〈x4,xF〉;
+〈xC,x1〉;〈x4,xF〉;〈x1,xA〉;〈x6,x1〉;〈x9,x6〉;〈x0,xB〉;〈x0,x0〉;〈x6,xF〉;〈x2,x6〉;〈x8,xC〉;〈xE,xE〉;〈x9,x3〉;〈x1,xB〉;〈x9,xE〉;〈xA,x5〉;〈x9,x6〉;
+〈x2,xA〉;〈xE,xB〉;〈x4,x6〉;〈x5,xF〉;〈x3,xC〉;〈xD,x6〉;〈x2,xD〉;〈x9,x4〉;〈x6,xB〉;〈xF,x4〉;〈xD,xA〉;〈x6,x9〉;〈x5,x9〉;〈xA,xC〉;〈xB,xD〉;〈x9,xE〉;
+〈x4,x8〉;〈x0,x2〉;〈xD,xC〉;〈x5,xC〉;〈x6,x0〉;〈x2,xA〉;〈x6,xE〉;〈xC,xA〉;〈x6,xE〉;〈x1,xF〉;〈xD,x4〉;〈x3,xA〉;〈xB,x0〉;〈x9,xE〉;〈x8,xF〉;〈xA,xB〉;
+〈xB,x2〉;〈x0,x2〉;〈x4,x7〉;〈x7,xD〉;〈xA,xB〉;〈xD,xB〉;〈xB,x5〉;〈x6,xD〉;〈xE,x2〉;〈x8,x9〉;〈x4,xD〉;〈x0,x4〉;〈xB,xE〉;〈xF,xA〉;〈x2,x2〉;〈x1,x4〉;
+〈x7,x1〉;〈x1,x2〉;〈x1,xB〉;〈x0,xD〉;〈xB,xA〉;〈x5,xA〉;〈x6,xC〉;〈x1,xE〉;〈x3,xA〉;〈x0,xF〉;〈x6,xE〉;〈x4,x4〉;〈xC,x8〉;〈xB,x5〉;〈x8,xC〉;〈x0,x3〉;
+〈x0,x6〉;〈x6,x4〉;〈x8,x5〉;〈x2,x8〉;〈x6,x4〉;〈x2,x2〉;〈x8,x1〉;〈x7,x6〉;〈xF,xE〉;〈xF,xA〉;〈x6,x2〉;〈x9,x1〉;〈xB,xE〉;〈xB,xC〉;〈x6,x1〉;〈x4,xB〉;
+〈x7,xE〉;〈x5,x0〉;〈xB,xC〉;〈xE,xE〉;〈x6,x3〉;〈xC,xF〉;〈x1,xD〉;〈xF,xD〉;〈x6,x2〉;〈x5,xC〉;〈x8,x5〉;〈x9,xE〉;〈xA,x5〉;〈x2,x6〉;〈xE,x7〉;〈x4,x6〉;
+〈x3,xB〉;〈xE,xA〉;〈xB,xE〉;〈x0,x4〉;〈x8,x8〉;〈xF,x2〉;〈x9,x2〉;〈x0,xB〉;〈xD,x9〉;〈xE,x9〉;〈x2,x9〉;〈x3,x8〉;〈x8,x8〉;〈x8,xA〉;〈x6,x9〉;〈x1,x7〉;
+〈x4,xB〉;〈xB,xF〉;〈x0,xC〉;〈xF,x2〉;〈xF,xD〉;〈x7,x3〉;〈x5,x9〉;〈xB,xE〉;〈x5,x4〉;〈x1,xC〉;〈xD,x3〉;〈x3,x1〉;〈x6,x2〉;〈x1,xB〉;〈xB,x7〉;〈x3,x2〉;
+〈xA,x4〉;〈xF,x1〉;〈x7,x0〉;〈x9,xA〉;〈x4,x6〉;〈xA,x1〉;〈x1,xC〉;〈x0,x4〉;〈x6,xC〉;〈xF,x2〉;〈xE,x6〉;〈xC,x1〉;〈xA,x4〉;〈xF,x2〉;〈x2,xA〉;〈x4,xB〉;
+〈x3,x5〉;〈x9,xB〉;〈x9,x9〉;〈xF,xF〉;〈x0,x1〉;〈x1,x3〉;〈xF,x9〉;〈x5,xC〉;〈x3,xC〉;〈x5,x1〉;〈x8,xA〉;〈xA,x5〉;〈x5,xF〉;〈x9,xE〉;〈x5,xE〉;〈xC,x6〉;
+
+〈x2,x1〉;〈x3,x7〉;〈xD,x2〉;〈xB,x9〉;〈x9,x8〉;〈xA,x1〉;〈x6,x0〉;〈xE,x9〉;〈x4,x5〉;〈xC,xA〉;〈xD,x7〉;〈xB,xD〉;〈xC,xF〉;〈x0,xF〉;〈x2,x4〉;〈xE,x5〉;
+〈x7,x9〉;〈x4,xB〉;〈x1,xC〉;〈x5,x7〉;〈x3,xA〉;〈x2,x4〉;〈x2,x2〉;〈x0,x8〉;〈x3,x3〉;〈xE,x2〉;〈xA,x2〉;〈x5,x8〉;〈x2,x5〉;〈x5,x4〉;〈x7,x1〉;〈x2,xB〉;
+〈xF,xF〉;〈xE,xD〉;〈x4,x8〉;〈xF,x6〉;〈x2,x3〉;〈x3,x1〉;〈xB,xA〉;〈x5,x1〉;〈x9,xF〉;〈xA,xA〉;〈xC,xC〉;〈x0,x3〉;〈x1,x5〉;〈xC,x7〉;〈x2,xD〉;〈xD,x3〉;
+〈xE,xB〉;〈x8,xF〉;〈x8,x4〉;〈x4,x0〉;〈x5,x3〉;〈xA,xD〉;〈x6,x7〉;〈xE,xC〉;〈xA,xF〉;〈xD,xC〉;〈x1,xC〉;〈x7,x4〉;〈x6,xB〉;〈xA,xD〉;〈xC,xD〉;〈xA,x7〉;
+〈x1,x1〉;〈x1,x0〉;〈xC,xF〉;〈xB,xE〉;〈xA,x1〉;〈x0,x1〉;〈x3,xF〉;〈xC,x0〉;〈x8,x5〉;〈x2,x8〉;〈x6,xB〉;〈xC,x3〉;〈x6,xD〉;〈xD,x8〉;〈x7,x5〉;〈x5,xA〉;
+〈xF,x0〉;〈x2,x2〉;〈x4,xB〉;〈x9,xC〉;〈x3,x1〉;〈xE,x4〉;〈xE,x7〉;〈xC,x6〉;〈xF,xC〉;〈x3,x0〉;〈xD,x5〉;〈xF,x9〉;〈x1,xA〉;〈x4,x0〉;〈x1,xF〉;〈x6,xD〉;
+〈xD,x5〉;〈x7,x8〉;〈xB,x5〉;〈x7,x6〉;〈xC,x9〉;〈xE,x1〉;〈xD,xF〉;〈x1,x2〉;〈x6,x1〉;〈xD,xF〉;〈x9,xF〉;〈x5,x7〉;〈x7,xD〉;〈x0,xB〉;〈xA,xD〉;〈x5,xA〉;
+〈xA,x1〉;〈x8,x4〉;〈xE,x5〉;〈xF,x7〉;〈xB,xC〉;〈xD,x3〉;〈xA,x5〉;〈xB,x4〉;〈x8,x5〉;〈x6,x7〉;〈x3,x6〉;〈xF,xC〉;〈xB,x1〉;〈xB,x3〉;〈xC,xB〉;〈x1,xE〉;
+〈xE,xC〉;〈x6,xE〉;〈xE,x1〉;〈x1,xC〉;〈xA,x5〉;〈x5,x3〉;〈x9,x8〉;〈xF,x6〉;〈xD,xF〉;〈x4,x1〉;〈x1,x3〉;〈x2,xE〉;〈x7,xF〉;〈x0,xE〉;〈x3,x8〉;〈x3,xC〉;
+〈xD,x4〉;〈x8,xC〉;〈x2,xA〉;〈x2,x8〉;〈x4,xE〉;〈x7,xE〉;〈x0,xE〉;〈xF,x7〉;〈xC,xA〉;〈x3,xE〉;〈xE,x4〉;〈xB,x4〉;〈x0,x5〉;〈x5,x8〉;〈xD,xC〉;〈x7,x8〉;
+〈xD,x9〉;〈xF,x9〉;〈x7,x9〉;〈x8,x4〉;〈x0,x2〉;〈x3,xF〉;〈xC,xF〉;〈x3,x8〉;〈xD,x7〉;〈x2,x6〉;〈x1,xD〉;〈x1,x8〉;〈x4,xD〉;〈xE,xA〉;〈x7,xA〉;〈xD,x4〉;
+〈x2,x4〉;〈x0,xD〉;〈x4,xD〉;〈x9,x0〉;〈x1,x7〉;〈x1,xE〉;〈x6,xE〉;〈xB,x6〉;〈xC,xC〉;〈xC,x0〉;〈xB,x0〉;〈x5,xE〉;〈x9,x9〉;〈x6,xD〉;〈xC,xF〉;〈xE,xE〉;
+〈x2,x9〉;〈xC,xF〉;〈xA,x2〉;〈x0,xC〉;〈xA,xB〉;〈x7,x4〉;〈x2,x9〉;〈x4,xE〉;〈x8,x2〉;〈x9,x3〉;〈x6,x9〉;〈x7,xB〉;〈xE,xC〉;〈xC,x7〉;〈x8,x9〉;〈xC,xA〉;
+〈xD,xD〉;〈xA,xC〉;〈x6,x5〉;〈x8,x0〉;〈x1,x4〉;〈x0,x9〉;〈x5,x5〉;〈x0,xE〉;〈x8,x4〉;〈x5,xE〉;〈x6,xF〉;〈x3,x4〉;〈x1,x8〉;〈xC,x9〉;〈x8,xB〉;〈xE,x4〉;
+〈x3,xE〉;〈xC,x4〉;〈x1,x6〉;〈xA,x4〉;〈x1,x9〉;〈x3,x4〉;〈x0,xE〉;〈x5,xE〉;〈xF,x9〉;〈x0,x3〉;〈x1,x3〉;〈x7,x2〉;〈x2,x7〉;〈x2,x8〉;〈xA,x7〉;〈x6,xD〉;
+〈xC,x1〉;〈x1,xD〉;〈xF,x0〉;〈x2,x8〉;〈xF,xB〉;〈xF,x6〉;〈x3,x8〉;〈x0,x1〉;〈xF,x9〉;〈xB,xC〉;〈x6,x6〉;〈xF,x8〉;〈x6,xE〉;〈xD,x1〉;〈xB,x5〉;〈x3,x8〉;
+
+〈x4,x3〉;〈xB,x6〉;〈x6,x8〉;〈xA,xC〉;〈x0,x9〉;〈xF,xD〉;〈x0,x9〉;〈x6,x8〉;〈xE,x0〉;〈x2,x2〉;〈xA,xF〉;〈x4,x0〉;〈x2,x6〉;〈x0,xC〉;〈x5,x2〉;〈xA,x7〉;
+〈xA,xD〉;〈xC,x3〉;〈x8,x2〉;〈xD,xC〉;〈x3,xC〉;〈x6,x5〉;〈xF,x2〉;〈xE,x8〉;〈xC,x0〉;〈x0,x6〉;〈x6,x4〉;〈xB,x1〉;〈x2,x0〉;〈x9,x5〉;〈x2,x2〉;〈xD,xD〉;
+〈xA,xD〉;〈xF,xF〉;〈x1,xB〉;〈x8,xB〉;〈xB,x6〉;〈x4,xA〉;〈xB,xB〉;〈x9,x8〉;〈x1,xA〉;〈xE,xC〉;〈x7,xB〉;〈xA,x6〉;〈x2,xC〉;〈xE,x1〉;〈xC,x7〉;〈xD,xC〉;
+〈x1,x9〉;〈x0,x6〉;〈x0,xA〉;〈x9,xF〉;〈x5,x2〉;〈x2,xB〉;〈xC,xA〉;〈x2,xF〉;〈x4,x0〉;〈xF,x8〉;〈xE,xA〉;〈x8,x7〉;〈x8,x9〉;〈xF,xD〉;〈x5,xD〉;〈x0,x0〉;
+〈x6,xE〉;〈x0,x0〉;〈x0,xD〉;〈x3,x0〉;〈x4,x3〉;〈x5,xA〉;〈x8,xF〉;〈x8,xA〉;〈xA,x4〉;〈x5,x0〉;〈x8,xF〉;〈x0,xC〉;〈x7,x7〉;〈xF,x2〉;〈x6,x5〉;〈xE,x4〉;
+〈x2,xD〉;〈xE,x5〉;〈xA,x8〉;〈x7,xF〉;〈x7,x8〉;〈xE,x3〉;〈x9,x5〉;〈xD,xA〉;〈x0,x7〉;〈x2,x9〉;〈x5,x1〉;〈x9,x4〉;〈xE,x4〉;〈x0,x1〉;〈xB,xF〉;〈x6,xE〉;
+〈x9,x8〉;〈x9,xC〉;〈x9,x0〉;〈xA,x8〉;〈x0,xA〉;〈x3,xD〉;〈x3,xC〉;〈x5,x0〉;〈xE,xB〉;〈x1,x2〉;〈xC,x4〉;〈x5,xF〉;〈x4,x7〉;〈x7,xB〉;〈x2,xC〉;〈xD,xF〉;
+〈x7,x8〉;〈x1,x3〉;〈x7,x4〉;〈xE,x0〉;〈x7,xB〉;〈x7,x1〉;〈x4,x7〉;〈x4,x8〉;〈x1,xB〉;〈xE,x3〉;〈x6,xB〉;〈x0,xB〉;〈x4,xB〉;〈x5,x9〉;〈x9,x3〉;〈xD,xF〉;
+〈xE,x1〉;〈x1,xB〉;〈xD,x0〉;〈xE,xD〉;〈x4,x7〉;〈x4,xD〉;〈xC,x2〉;〈xD,xE〉;〈x5,xC〉;〈xD,xA〉;〈x9,x5〉;〈xC,x8〉;〈x1,x0〉;〈x7,x7〉;〈x7,xF〉;〈xC,x0〉;
+〈xA,x7〉;〈xD,x3〉;〈xD,x3〉;〈xD,x8〉;〈x3,x4〉;〈xA,x1〉;〈x1,x5〉;〈xE,x0〉;〈x0,x4〉;〈x1,xE〉;〈x8,x2〉;〈xC,xA〉;〈xD,x9〉;〈x1,x1〉;〈xB,x1〉;〈xC,x9〉;
+〈x4,xC〉;〈x4,xB〉;〈x0,x9〉;〈x4,x8〉;〈xF,xC〉;〈xD,xD〉;〈x6,xE〉;〈xC,xA〉;〈x7,x6〉;〈xA,xE〉;〈x8,xE〉;〈x3,xB〉;〈xF,xB〉;〈x6,x5〉;〈x8,x3〉;〈x1,xD〉;
+〈xD,xB〉;〈xA,xE〉;〈x4,xF〉;〈xC,x6〉;〈x1,xE〉;〈xC,x5〉;〈xC,xC〉;〈x7,xC〉;〈x2,x8〉;〈xF,x9〉;〈xD,x2〉;〈x8,x6〉;〈x1,x5〉;〈xF,xA〉;〈x4,x1〉;〈x4,x5〉;
+〈x2,xE〉;〈x9,x5〉;〈xB,xF〉;〈x0,xD〉;〈x8,xB〉;〈x8,xD〉;〈x1,x1〉;〈x9,xC〉;〈xB,x8〉;〈xF,xB〉;〈x2,x6〉;〈xD,x6〉;〈x9,x1〉;〈x0,xD〉;〈xC,xD〉;〈x0,x7〉;
+〈x5,x0〉;〈xF,xA〉;〈x2,x9〉;〈x3,xF〉;〈x0,xC〉;〈x2,xB〉;〈xF,xE〉;〈x9,x7〉;〈x5,x5〉;〈x5,xA〉;〈x6,xD〉;〈x9,x6〉;〈x0,x5〉;〈x0,x9〉;〈x4,x5〉;〈xE,xF〉;
+〈x0,xF〉;〈x7,x4〉;〈x9,x3〉;〈x6,xC〉;〈x8,x2〉;〈x3,x7〉;〈xE,xB〉;〈x5,x0〉;〈xF,x5〉;〈xC,x4〉;〈x0,xB〉;〈x3,x8〉;〈x2,xD〉;〈x8,xA〉;〈x9,x3〉;〈x6,xD〉;
+〈x1,xD〉;〈xE,x5〉;〈xF,x7〉;〈xE,x7〉;〈xD,x7〉;〈x5,xC〉;〈xB,x4〉;〈x5,x0〉;〈x7,x5〉;〈x0,xD〉;〈xF,x3〉;〈xC,xE〉;〈x3,x1〉;〈xF,x1〉;〈x8,xE〉;〈x8,xF〉;
+
+〈xD,xB〉;〈x1,x4〉;〈xF,x6〉;〈x0,x3〉;〈xA,xB〉;〈xA,xE〉;〈xB,xC〉;〈xE,xB〉;〈xC,x8〉;〈x6,x7〉;〈xC,xC〉;〈xF,xF〉;〈x4,xF〉;〈xC,x6〉;〈x2,x9〉;〈x9,x5〉;
+〈xB,xC〉;〈x6,x5〉;〈x5,x2〉;〈xF,x2〉;〈x3,x5〉;〈xC,x4〉;〈xF,x4〉;〈x9,xB〉;〈x4,x5〉;〈x1,xC〉;〈xD,xB〉;〈x6,x1〉;〈xF,xE〉;〈x3,xF〉;〈xB,x9〉;〈xD,x8〉;
+〈xF,x1〉;〈xA,xC〉;〈x0,x7〉;〈xA,x4〉;〈xB,x8〉;〈x8,x8〉;〈x9,x5〉;〈xB,x8〉;〈x5,x6〉;〈x3,x2〉;〈x5,xA〉;〈x3,xE〉;〈x2,x2〉;〈x0,xB〉;〈x9,x6〉;〈xE,xE〉;
+〈x6,xF〉;〈x1,xE〉;〈x3,x2〉;〈x4,x9〉;〈x4,xF〉;〈xC,xC〉;〈xD,xB〉;〈x5,x1〉;〈x4,xD〉;〈xD,x1〉;〈x4,xF〉;〈x0,x9〉;〈x5,xA〉;〈xA,xC〉;〈xE,x7〉;〈x8,x6〉;
+〈x5,x8〉;〈xA,x5〉;〈xA,x7〉;〈x5,xE〉;〈x3,x6〉;〈x1,x1〉;〈x3,xA〉;〈x8,x9〉;〈x8,x2〉;〈xD,xC〉;〈x6,x2〉;〈x0,xE〉;〈xA,xB〉;〈x2,xB〉;〈x2,x5〉;〈xF,x9〉;
+〈x7,x7〉;〈x8,x6〉;〈x1,xD〉;〈x7,x9〉;〈x5,x1〉;〈xB,xD〉;〈x9,x8〉;〈xB,x7〉;〈xB,xB〉;〈xF,x6〉;〈xD,x9〉;〈x6,x6〉;〈x0,x1〉;〈x1,x2〉;〈xE,xB〉;〈x0,xA〉;
+〈xC,xD〉;〈x1,xA〉;〈xA,xA〉;〈xC,xC〉;〈x6,x5〉;〈x4,x2〉;〈x8,xF〉;〈x2,xA〉;〈x4,x8〉;〈xC,x6〉;〈xB,xA〉;〈xD,x8〉;〈x2,xD〉;〈x2,x9〉;〈xE,x8〉;〈x5,x7〉;
+〈x7,x7〉;〈x7,xA〉;〈xB,x4〉;〈x4,x9〉;〈x6,x5〉;〈x4,x3〉;〈x5,x7〉;〈xF,xE〉;〈xC,x6〉;〈xC,x7〉;〈x6,x2〉;〈x6,x7〉;〈x5,x8〉;〈xD,x6〉;〈x9,xA〉;〈xC,x8〉;
+〈xE,x8〉;〈x3,x0〉;〈x6,x0〉;〈x7,x3〉;〈x8,x9〉;〈x2,x3〉;〈x0,x8〉;〈x7,xA〉;〈xA,xC〉;〈x5,xD〉;〈x6,xD〉;〈xC,xE〉;〈x0,xC〉;〈x1,xB〉;〈x1,x7〉;〈xC,x1〉;
+〈x4,x2〉;〈x5,x3〉;〈x1,x5〉;〈x7,xC〉;〈x7,x4〉;〈x2,xB〉;〈x2,x5〉;〈x5,x6〉;〈x6,x1〉;〈xE,xC〉;〈x0,xB〉;〈x4,x2〉;〈x0,x4〉;〈xC,xA〉;〈x0,x9〉;〈xA,xB〉;
+〈x1,xB〉;〈xD,x0〉;〈x9,xF〉;〈x6,xA〉;〈x7,xF〉;〈x4,x1〉;〈xF,x8〉;〈xE,xA〉;〈x8,x2〉;〈x8,x1〉;〈x4,x1〉;〈xC,xE〉;〈xC,xE〉;〈x0,xD〉;〈x2,xB〉;〈x3,x3〉;
+〈xA,x3〉;〈x6,x4〉;〈xF,xA〉;〈xA,x6〉;〈x3,x9〉;〈x7,xF〉;〈xF,x6〉;〈xB,x2〉;〈x5,x5〉;〈x6,xB〉;〈xA,xC〉;〈x3,x3〉;〈x9,x3〉;〈xE,x7〉;〈xB,xE〉;〈x3,x4〉;
+〈xC,xF〉;〈xE,xF〉;〈xA,x2〉;〈xE,xE〉;〈xE,xD〉;〈xC,xB〉;〈xB,x0〉;〈x8,x9〉;〈xD,xA〉;〈x3,xB〉;〈xB,xE〉;〈x3,xE〉;〈x3,x3〉;〈x5,x1〉;〈xA,x5〉;〈x3,xC〉;
+〈xC,xC〉;〈xA,x0〉;〈xF,xD〉;〈x3,x9〉;〈xC,xB〉;〈xF,xC〉;〈x1,xF〉;〈x8,xD〉;〈x6,x8〉;〈xD,x4〉;〈x8,xC〉;〈xA,xA〉;〈x8,xE〉;〈x3,xA〉;〈x9,x7〉;〈x2,x6〉;
+〈x6,xB〉;〈xA,xC〉;〈x8,xA〉;〈x4,xB〉;〈x7,x4〉;〈x3,xF〉;〈xB,x7〉;〈xB,xF〉;〈x0,xC〉;〈xE,x6〉;〈xC,xD〉;〈x4,x2〉;〈xF,xA〉;〈xE,xE〉;〈xF,x9〉;〈x0,xC〉;
+〈x2,xC〉;〈x7,x9〉;〈x7,xE〉;〈xD,x8〉;〈x4,x0〉;〈x7,xC〉;〈x3,x8〉;〈x4,x9〉;〈x7,x1〉;〈x7,x5〉;〈xB,x7〉;〈x3,x6〉;〈x0,x7〉;〈x1,xA〉;〈x2,xC〉;〈x1,xE〉;
+
+〈x3,xC〉;〈x7,xA〉;〈x3,x8〉;〈x4,xA〉;〈x3,x4〉;〈x2,x0〉;〈x9,x5〉;〈x6,x0〉;〈xF,x7〉;〈xC,x3〉;〈xB,x1〉;〈x6,xE〉;〈xB,x1〉;〈x7,x0〉;〈x7,x4〉;〈x3,xB〉;
+〈x0,xD〉;〈x6,xD〉;〈xF,xB〉;〈xE,x5〉;〈xE,x2〉;〈x6,x6〉;〈x6,x8〉;〈x0,x8〉;〈xF,xB〉;〈x3,xC〉;〈x8,xC〉;〈xD,xD〉;〈x0,x2〉;〈x2,xE〉;〈x6,xE〉;〈xF,x1〉;
+〈xA,xF〉;〈x7,x9〉;〈x6,x7〉;〈xE,x2〉;〈x4,xC〉;〈xA,x5〉;〈x7,x9〉;〈xC,x6〉;〈xB,x5〉;〈xA,xF〉;〈x1,x5〉;〈xF,xE〉;〈xE,x2〉;〈x2,xB〉;〈xC,xA〉;〈xE,x6〉;
+〈x3,xE〉;〈x2,xC〉;〈x5,x8〉;〈x7,x2〉;〈xC,xE〉;〈x7,x1〉;〈x8,xC〉;〈xB,xE〉;〈x2,x0〉;〈x6,x6〉;〈x0,x7〉;〈x6,xF〉;〈xD,x1〉;〈x8,x2〉;〈x3,x1〉;〈xF,x3〉;
+〈x9,x5〉;〈x9,x1〉;〈x1,x2〉;〈xF,x3〉;〈x4,xF〉;〈x6,xC〉;〈xA,x6〉;〈x8,xE〉;〈xB,x2〉;〈x7,x8〉;〈xD,xE〉;〈x7,x9〉;〈xC,x5〉;〈x2,x2〉;〈xF,x3〉;〈x0,x7〉;
+〈xE,x7〉;〈x9,xE〉;〈x9,x2〉;〈x7,x3〉;〈x3,xC〉;〈xA,x1〉;〈xD,xA〉;〈x2,x1〉;〈x2,x3〉;〈x4,x5〉;〈xE,x5〉;〈x7,x4〉;〈x8,x4〉;〈xC,x2〉;〈x6,x8〉;〈x3,x5〉;
+〈x9,xA〉;〈xC,x8〉;〈x2,xE〉;〈x1,xD〉;〈xD,x1〉;〈xA,x6〉;〈xD,xF〉;〈x0,x6〉;〈x7,xF〉;〈x8,xC〉;〈x2,x8〉;〈xF,x6〉;〈xC,x3〉;〈xF,x8〉;〈x6,x2〉;〈xF,x9〉;
+〈x5,x7〉;〈x2,x7〉;〈xD,x1〉;〈xD,x3〉;〈x0,xB〉;〈xA,x3〉;〈x8,x7〉;〈x8,x3〉;〈xC,x9〉;〈x1,x4〉;〈xB,x4〉;〈xC,x5〉;〈xE,xD〉;〈x5,x4〉;〈xE,x1〉;〈xB,x9〉;
+〈x2,x9〉;〈x6,xF〉;〈xE,x3〉;〈x0,xD〉;〈xC,xC〉;〈xF,x6〉;〈x0,xD〉;〈x2,x4〉;〈x4,x5〉;〈x6,xE〉;〈xE,x4〉;〈xD,xB〉;〈xF,x9〉;〈xC,x1〉;〈xD,x4〉;〈xB,x4〉;
+〈xB,x5〉;〈x6,x6〉;〈x1,xC〉;〈x6,xE〉;〈xA,xF〉;〈x4,x0〉;〈xE,x6〉;〈x4,x9〉;〈x7,xE〉;〈x4,x1〉;〈x1,x8〉;〈x8,x7〉;〈xD,xF〉;〈xB,xB〉;〈x6,x0〉;〈x0,x5〉;
+〈xF,x4〉;〈x5,xD〉;〈xA,x1〉;〈xD,x6〉;〈x6,x7〉;〈x2,xA〉;〈xC,x8〉;〈x7,x7〉;〈xF,x9〉;〈x8,xA〉;〈xF,x9〉;〈x2,x6〉;〈xE,xF〉;〈x7,x4〉;〈x5,x8〉;〈x6,xA〉;
+〈xC,x8〉;〈x3,x5〉;〈x1,x0〉;〈xC,x5〉;〈x1,xE〉;〈x0,xB〉;〈x8,x3〉;〈x6,xA〉;〈x4,x4〉;〈x8,xD〉;〈x5,xC〉;〈xF,xB〉;〈xF,xE〉;〈x9,x2〉;〈x0,x3〉;〈x4,x3〉;
+〈x0,x5〉;〈xA,xF〉;〈xC,x0〉;〈xF,x3〉;〈x0,x4〉;〈x2,x8〉;〈x9,xD〉;〈x0,x9〉;〈x3,x5〉;〈xE,x3〉;〈x5,xF〉;〈x4,x5〉;〈xA,xB〉;〈xC,xD〉;〈x8,xC〉;〈xF,xD〉;
+〈x2,xC〉;〈x9,xD〉;〈xA,xF〉;〈x6,x4〉;〈x4,x3〉;〈x8,x0〉;〈x8,x2〉;〈xE,x5〉;〈x8,xE〉;〈x3,xD〉;〈x2,xD〉;〈xD,xB〉;〈xD,xF〉;〈xA,xB〉;〈x0,x8〉;〈x1,x6〉;
+〈xE,xC〉;〈x7,xE〉;〈xA,x7〉;〈xC,xB〉;〈xD,x8〉;〈x5,xC〉;〈x2,xC〉;〈x8,x8〉;〈x9,x8〉;〈xC,x2〉;〈xA,xD〉;〈x1,xD〉;〈xB,x0〉;〈xB,x1〉;〈xC,xE〉;〈x9,x3〉;
+〈xE,x2〉;〈xF,x4〉;〈xD,xB〉;〈xA,x5〉;〈xB,x6〉;〈x4,x9〉;〈x8,x7〉;〈x1,xD〉;〈xA,x2〉;〈x7,x9〉;〈x3,x5〉;〈xB,xE〉;〈x5,x5〉;〈xC,xD〉;〈x6,x3〉;〈x2,xC〉;
+
+〈x1,x0〉;〈x1,xF〉;〈xE,xC〉;〈x3,xB〉;〈x8,xA〉;〈x3,xF〉;〈x3,x8〉;〈x8,x0〉;〈x1,xC〉;〈x2,xD〉;〈x9,x2〉;〈x5,xF〉;〈xE,x1〉;〈xB,x5〉;〈xB,xC〉;〈x8,x3〉;
+〈xB,x6〉;〈x1,xB〉;〈xE,xD〉;〈x4,xF〉;〈x3,xA〉;〈xC,x4〉;〈xF,xE〉;〈xF,xF〉;〈xC,xB〉;〈x8,x1〉;〈x6,x7〉;〈xC,x2〉;〈x5,x9〉;〈xD,xA〉;〈x0,xA〉;〈x9,xC〉;
+〈x2,x2〉;〈xE,xB〉;〈x9,x3〉;〈xE,x2〉;〈x7,xF〉;〈xA,xC〉;〈x4,xA〉;〈x8,x2〉;〈x8,x1〉;〈x3,xF〉;〈xE,xB〉;〈x8,xB〉;〈x0,xF〉;〈x9,xC〉;〈x4,x1〉;〈x8,x2〉;
+〈x9,xB〉;〈x7,xC〉;〈x5,x1〉;〈xA,x7〉;〈xA,xB〉;〈xA,xD〉;〈x9,x2〉;〈x1,x9〉;〈xF,x0〉;〈xF,xD〉;〈x9,x3〉;〈xF,x6〉;〈xA,xD〉;〈x2,x4〉;〈xC,xB〉;〈xD,xE〉;
+〈xB,x5〉;〈xA,xB〉;〈x8,x1〉;〈x5,x4〉;〈xA,xE〉;〈x2,x4〉;〈x6,x4〉;〈xD,x2〉;〈xD,x0〉;〈xF,xE〉;〈x3,x3〉;〈x2,xA〉;〈x7,x5〉;〈x0,x7〉;〈x8,xF〉;〈x3,xA〉;
+〈x1,x2〉;〈x9,xF〉;〈xB,xE〉;〈x1,xB〉;〈x1,xB〉;〈x1,xF〉;〈xC,x7〉;〈xF,x1〉;〈x7,xC〉;〈x9,x1〉;〈x5,xD〉;〈x3,x2〉;〈xD,x9〉;〈xD,x6〉;〈xE,xA〉;〈x0,x6〉;
+〈x5,xB〉;〈x6,x9〉;〈x6,xB〉;〈xA,xC〉;〈x0,x9〉;〈x1,x6〉;〈xA,x3〉;〈xC,xA〉;〈x8,xE〉;〈x8,x3〉;〈x3,x4〉;〈xB,x7〉;〈x4,x1〉;〈x2,x7〉;〈xB,x3〉;〈x0,x1〉;
+〈xE,x6〉;〈x0,x6〉;〈x8,xC〉;〈x0,x4〉;〈x3,xD〉;〈xB,xE〉;〈x2,xC〉;〈x6,x6〉;〈xB,x5〉;〈x8,x6〉;〈x1,x1〉;〈x1,x3〉;〈x6,xD〉;〈xD,x0〉;〈xB,xE〉;〈x8,xD〉;
+〈xC,x7〉;〈x5,x5〉;〈x0,x2〉;〈xC,x1〉;〈x7,x6〉;〈x5,xF〉;〈x2,x0〉;〈x5,xE〉;〈xE,x4〉;〈x3,xE〉;〈x7,x7〉;〈xE,x1〉;〈x3,xF〉;〈xE,x8〉;〈x6,xC〉;〈x4,xA〉;
+〈xA,x0〉;〈xF,xE〉;〈xC,xE〉;〈x3,xF〉;〈x6,x7〉;〈x9,x4〉;〈x3,xF〉;〈xE,xF〉;〈xE,xF〉;〈x8,x6〉;〈xD,x9〉;〈x4,xA〉;〈x0,x8〉;〈x8,xB〉;〈xC,x8〉;〈x1,xC〉;
+〈xA,xD〉;〈x2,x0〉;〈xA,x7〉;〈x8,xC〉;〈x0,x6〉;〈x6,x7〉;〈xA,xF〉;〈x7,x3〉;〈xC,xD〉;〈x1,x6〉;〈x8,x4〉;〈x3,x2〉;〈xD,x0〉;〈xF,x3〉;〈xD,xC〉;〈xD,xB〉;
+〈xB,x7〉;〈x2,x4〉;〈x6,xA〉;〈x6,x3〉;〈x1,xC〉;〈xA,x1〉;〈xD,xE〉;〈xB,xC〉;〈x9,x2〉;〈xF,x1〉;〈x5,xC〉;〈xE,x7〉;〈xE,x0〉;〈xD,x5〉;〈xA,x4〉;〈x4,xA〉;
+〈x0,x0〉;〈xD,x6〉;〈x2,x2〉;〈x9,xC〉;〈x5,x2〉;〈x8,xF〉;〈xE,x8〉;〈x2,x2〉;〈xA,x2〉;〈xF,x0〉;〈x9,x8〉;〈x3,x8〉;〈x0,xD〉;〈xF,x6〉;〈x4,x3〉;〈x7,x9〉;
+〈x8,x2〉;〈xA,xF〉;〈xD,x5〉;〈xC,x1〉;〈x8,x2〉;〈x5,x2〉;〈xD,xB〉;〈x8,xF〉;〈x7,xE〉;〈xD,x1〉;〈x9,xD〉;〈xA,x6〉;〈x8,xE〉;〈x9,xE〉;〈xA,x9〉;〈x8,xE〉;
+〈xD,x1〉;〈xF,x6〉;〈xB,x0〉;〈xE,xA〉;〈x8,x3〉;〈xE,x9〉;〈xF,x7〉;〈x3,xB〉;〈x4,xA〉;〈x0,x9〉;〈x1,xE〉;〈x3,x2〉;〈xD,x2〉;〈x5,xD〉;〈xD,x7〉;〈xA,xB〉;
+〈x4,xD〉;〈x6,xF〉;〈x5,x9〉;〈xF,xC〉;〈x4,x3〉;〈x4,x1〉;〈x0,x0〉;〈x3,xC〉;〈x9,x4〉;〈x5,x2〉;〈x5,x9〉;〈x6,xC〉;〈x6,xE〉;〈xE,x8〉;〈x6,x6〉;〈xF,x5〉;
+
+〈x9,xC〉;〈x5,x7〉;〈x6,xC〉;〈xE,x2〉;〈x3,xB〉;〈xA,x2〉;〈x2,x1〉;〈xE,xE〉;〈xF,x6〉;〈x4,xF〉;〈xF,x3〉;〈x6,x2〉;〈xD,xB〉;〈x8,xF〉;〈x6,x4〉;〈xD,x3〉;
+〈x8,x0〉;〈x6,x9〉;〈x9,x7〉;〈x4,x7〉;〈x8,xB〉;〈xB,x6〉;〈x3,x8〉;〈x4,x5〉;〈xB,xE〉;〈x0,xD〉;〈x6,x1〉;〈xC,xF〉;〈x7,x8〉;〈xC,xF〉;〈x4,x1〉;〈x7,xF〉;
+〈xF,x4〉;〈x5,xA〉;〈x8,xB〉;〈x7,x2〉;〈xE,x6〉;〈x7,xD〉;〈x4,xC〉;〈x1,x8〉;〈xE,xE〉;〈x3,xA〉;〈x1,x2〉;〈x9,x4〉;〈x3,x4〉;〈x3,x0〉;〈x3,x9〉;〈x0,x0〉;
+〈x9,x5〉;〈x6,x0〉;〈xF,xA〉;〈x7,xF〉;〈xA,x6〉;〈xC,x7〉;〈xB,x1〉;〈x7,xE〉;〈x0,xD〉;〈x2,x4〉;〈xF,xF〉;〈x4,x3〉;〈x7,x8〉;〈x8,x8〉;〈x6,xC〉;〈x0,x7〉;
+〈x7,x3〉;〈x9,x2〉;〈xC,x8〉;〈x0,xB〉;〈x5,x0〉;〈x9,x7〉;〈xF,x4〉;〈x1,xB〉;〈xD,xB〉;〈x4,x5〉;〈x6,x2〉;〈x9,x1〉;〈x8,x7〉;〈x5,xD〉;〈xF,x5〉;〈x6,x1〉;
+〈x3,x8〉;〈xF,x3〉;〈x8,xA〉;〈x4,xF〉;〈xD,xB〉;〈x3,xD〉;〈x4,x3〉;〈x2,xF〉;〈xB,xA〉;〈xA,x9〉;〈xB,x4〉;〈xA,x9〉;〈x2,x6〉;〈x7,xE〉;〈x8,xC〉;〈x1,x6〉;
+〈xF,xC〉;〈x1,xC〉;〈xA,x7〉;〈x9,xD〉;〈x7,xC〉;〈x8,x5〉;〈xA,x7〉;〈x3,x5〉;〈x8,x6〉;〈x4,xF〉;〈xC,x8〉;〈x9,xA〉;〈x0,xD〉;〈x2,x4〉;〈x0,x4〉;〈x5,x8〉;
+〈x4,x2〉;〈x3,x0〉;〈x7,x5〉;〈x8,xD〉;〈xB,xC〉;〈x7,x2〉;〈x3,x4〉;〈xF,x9〉;〈x4,x6〉;〈x5,xE〉;〈xF,x4〉;〈x5,xC〉;〈x6,x7〉;〈x0,x4〉;〈x8,x8〉;〈x2,x8〉;
+〈xA,x9〉;〈xE,xC〉;〈xE,xC〉;〈x7,xC〉;〈x4,x6〉;〈x6,xE〉;〈x1,xC〉;〈xD,x9〉;〈xC,x0〉;〈x6,x1〉;〈x5,x8〉;〈x5,xE〉;〈x3,x7〉;〈xB,x0〉;〈x9,x9〉;〈x9,x7〉;
+〈xA,x0〉;〈x9,xB〉;〈x7,x7〉;〈x4,xA〉;〈xD,x0〉;〈xB,x5〉;〈x1,xD〉;〈xA,x6〉;〈x4,xA〉;〈xC,x5〉;〈x3,xA〉;〈x9,x4〉;〈xB,x4〉;〈x5,x0〉;〈x0,x6〉;〈xC,x0〉;
+〈xA,x8〉;〈x0,x2〉;〈x5,xF〉;〈x0,xE〉;〈x2,x1〉;〈x0,x3〉;〈xB,x1〉;〈x9,x6〉;〈x0,x2〉;〈x9,x7〉;〈x8,x0〉;〈x1,xA〉;〈x0,xB〉;〈x3,xD〉;〈x2,x1〉;〈x7,xF〉;
+〈x0,x3〉;〈x2,x9〉;〈x3,x2〉;〈x6,x6〉;〈xB,xF〉;〈x3,xB〉;〈x5,x7〉;〈x5,x3〉;〈xE,x7〉;〈xD,x5〉;〈xE,x5〉;〈x4,x5〉;〈xA,x3〉;〈x1,xA〉;〈x1,xB〉;〈xF,x8〉;
+〈xC,xF〉;〈xB,x3〉;〈x9,x5〉;〈x5,x9〉;〈x4,xE〉;〈x6,x4〉;〈x4,x3〉;〈xF,x4〉;〈x2,x5〉;〈xC,xC〉;〈x6,x1〉;〈x3,x5〉;〈xD,xF〉;〈x3,x6〉;〈x5,x5〉;〈xC,xF〉;
+〈x9,xA〉;〈x1,x1〉;〈xF,x6〉;〈xD,x4〉;〈x4,xF〉;〈x9,xB〉;〈xA,xF〉;〈xF,x2〉;〈x0,x3〉;〈x1,x9〉;〈x9,xB〉;〈xA,xB〉;〈xC,x4〉;〈x1,x9〉;〈xA,x1〉;〈xE,xA〉;
+〈x1,xB〉;〈x2,x5〉;〈xA,xD〉;〈xA,xA〉;〈x0,x0〉;〈x5,xB〉;〈x9,xD〉;〈x6,xF〉;〈x8,x8〉;〈x6,xF〉;〈x3,x0〉;〈x8,x5〉;〈xC,x6〉;〈x1,x7〉;〈x5,x7〉;〈x1,x1〉;
+〈xA,xB〉;〈x0,x2〉;〈xD,xD〉;〈x9,x2〉;〈x4,xD〉;〈x8,x2〉;〈x0,x2〉;〈x3,x5〉;〈xC,xB〉;〈x4,x4〉;〈xA,x4〉;〈x4,x1〉;〈xD,x5〉;〈x1,x2〉;〈xE,x7〉;〈x4,xD〉;
diff --git a/helm/software/matita/contribs/assembly/freescale/Doc/daa_test.txt b/helm/software/matita/contribs/assembly/freescale/Doc/daa_test.txt
new file mode 100755
index 000000000..e74025396
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/freescale/Doc/daa_test.txt
@@ -0,0 +1,1334 @@
+sorgente utilizzato per produrre la tabella:
+
+unsigned int i;
+unsigned char val;
+
+for(i=0,val=0;i<0x100;i++,val++)
+ {
+ asm {
+  /* H=0 C=0 */
+  lda val
+  psha
+  tap
+  and #0x00
+  tpa
+  pula
+  daa
+  nop <- breakpoint/prelevare A,CCR
+
+  /* H=0 C=1 */
+  lda val
+  psha
+  tap
+  and #0x00
+  or  #0x01
+  tpa
+  pula
+  daa
+  nop <- breakpoint/prelevare A,CCR
+
+  /* H=1 C=0 */
+  lda val
+  psha
+  tap
+  and #0x00
+  or  #0x10
+  tpa
+  pula
+  daa
+  nop <- breakpoint/prelevare A,CCR
+
+  /* H=1 C=1 */
+  lda val
+  psha
+  tap
+  and #0x00
+  or  #0x11
+  tpa
+  pula
+  daa
+  nop <- breakpoint/prelevare A,CCR
+  }
+ }
+
+************************************************
+
+H(0) C(0) A(0x00) -> V(0) N(0) Z(1) C(0) A(0x00)
+H(0) C(1) A(0x00) -> V(0) N(0) Z(0) C(1) A(0x60)
+H(1) C(0) A(0x00) -> V(0) N(0) Z(0) C(0) A(0x06)
+H(1) C(1) A(0x00) -> V(0) N(0) Z(0) C(1) A(0x66)
+
+H(0) C(0) A(0x01) -> V(0) N(0) Z(0) C(0) A(0x01)
+H(0) C(1) A(0x01) -> V(0) N(0) Z(0) C(1) A(0x61)
+H(1) C(0) A(0x01) -> V(0) N(0) Z(0) C(0) A(0x07)
+H(1) C(1) A(0x01) -> V(0) N(0) Z(0) C(1) A(0x67)
+
+H(0) C(0) A(0x02) -> V(0) N(0) Z(0) C(0) A(0x02)
+H(0) C(1) A(0x02) -> V(0) N(0) Z(0) C(1) A(0x62)
+H(1) C(0) A(0x02) -> V(0) N(0) Z(0) C(0) A(0x08)
+H(1) C(1) A(0x02) -> V(0) N(0) Z(0) C(1) A(0x68)
+
+H(0) C(0) A(0x03) -> V(0) N(0) Z(0) C(0) A(0x03)
+H(0) C(1) A(0x03) -> V(0) N(0) Z(0) C(1) A(0x63)
+H(1) C(0) A(0x03) -> V(0) N(0) Z(0) C(0) A(0x09)
+H(1) C(1) A(0x03) -> V(0) N(0) Z(0) C(1) A(0x69)
+
+H(0) C(0) A(0x04) -> V(0) N(0) Z(0) C(0) A(0x04)
+H(0) C(1) A(0x04) -> V(0) N(0) Z(0) C(1) A(0x64)
+H(1) C(0) A(0x04) -> V(0) N(0) Z(0) C(0) A(0x0A)
+H(1) C(1) A(0x04) -> V(0) N(0) Z(0) C(1) A(0x6A)
+
+H(0) C(0) A(0x05) -> V(0) N(0) Z(0) C(0) A(0x05)
+H(0) C(1) A(0x05) -> V(0) N(0) Z(0) C(1) A(0x65)
+H(1) C(0) A(0x05) -> V(0) N(0) Z(0) C(0) A(0x0B)
+H(1) C(1) A(0x05) -> V(0) N(0) Z(0) C(1) A(0x6B)
+
+H(0) C(0) A(0x06) -> V(0) N(0) Z(0) C(0) A(0x06)
+H(0) C(1) A(0x06) -> V(0) N(0) Z(0) C(1) A(0x66)
+H(1) C(0) A(0x06) -> V(0) N(0) Z(0) C(0) A(0x0C)
+H(1) C(1) A(0x06) -> V(0) N(0) Z(0) C(1) A(0x6C)
+
+H(0) C(0) A(0x07) -> V(0) N(0) Z(0) C(0) A(0x07)
+H(0) C(1) A(0x07) -> V(0) N(0) Z(0) C(1) A(0x67)
+H(1) C(0) A(0x07) -> V(0) N(0) Z(0) C(0) A(0x0D)
+H(1) C(1) A(0x07) -> V(0) N(0) Z(0) C(1) A(0x6D)
+
+H(0) C(0) A(0x08) -> V(0) N(0) Z(0) C(0) A(0x08)
+H(0) C(1) A(0x08) -> V(0) N(0) Z(0) C(1) A(0x68)
+H(1) C(0) A(0x08) -> V(0) N(0) Z(0) C(0) A(0x0E)
+H(1) C(1) A(0x08) -> V(0) N(0) Z(0) C(1) A(0x6E)
+
+H(0) C(0) A(0x09) -> V(0) N(0) Z(0) C(0) A(0x09)
+H(0) C(1) A(0x09) -> V(0) N(0) Z(0) C(1) A(0x69)
+H(1) C(0) A(0x09) -> V(0) N(0) Z(0) C(0) A(0x0F)
+H(1) C(1) A(0x09) -> V(0) N(0) Z(0) C(1) A(0x6F)
+
+H(0) C(0) A(0x0A) -> V(0) N(0) Z(0) C(0) A(0x10)
+H(0) C(1) A(0x0A) -> V(0) N(0) Z(0) C(1) A(0x70)
+H(1) C(0) A(0x0A) -> V(0) N(0) Z(0) C(0) A(0x10)
+H(1) C(1) A(0x0A) -> V(0) N(0) Z(0) C(1) A(0x70)
+
+H(0) C(0) A(0x0B) -> V(0) N(0) Z(0) C(0) A(0x11)
+H(0) C(1) A(0x0B) -> V(0) N(0) Z(0) C(1) A(0x71)
+H(1) C(0) A(0x0B) -> V(0) N(0) Z(0) C(0) A(0x11)
+H(1) C(1) A(0x0B) -> V(0) N(0) Z(0) C(1) A(0x71)
+
+H(0) C(0) A(0x0C) -> V(0) N(0) Z(0) C(0) A(0x12)
+H(0) C(1) A(0x0C) -> V(0) N(0) Z(0) C(1) A(0x72)
+H(1) C(0) A(0x0C) -> V(0) N(0) Z(0) C(0) A(0x12)
+H(1) C(1) A(0x0C) -> V(0) N(0) Z(0) C(1) A(0x72)
+
+H(0) C(0) A(0x0D) -> V(0) N(0) Z(0) C(0) A(0x13)
+H(0) C(1) A(0x0D) -> V(0) N(0) Z(0) C(1) A(0x73)
+H(1) C(0) A(0x0D) -> V(0) N(0) Z(0) C(0) A(0x13)
+H(1) C(1) A(0x0D) -> V(0) N(0) Z(0) C(1) A(0x73)
+
+H(0) C(0) A(0x0E) -> V(0) N(0) Z(0) C(0) A(0x14)
+H(0) C(1) A(0x0E) -> V(0) N(0) Z(0) C(1) A(0x74)
+H(1) C(0) A(0x0E) -> V(0) N(0) Z(0) C(0) A(0x14)
+H(1) C(1) A(0x0E) -> V(0) N(0) Z(0) C(1) A(0x74)
+
+H(0) C(0) A(0x0F) -> V(0) N(0) Z(0) C(0) A(0x15)
+H(0) C(1) A(0x0F) -> V(0) N(0) Z(0) C(1) A(0x75)
+H(1) C(0) A(0x0F) -> V(0) N(0) Z(0) C(0) A(0x15)
+H(1) C(1) A(0x0F) -> V(0) N(0) Z(0) C(1) A(0x75)
+
+H(0) C(0) A(0x10) -> V(0) N(0) Z(0) C(0) A(0x10)
+H(0) C(1) A(0x10) -> V(0) N(0) Z(0) C(1) A(0x70)
+H(1) C(0) A(0x10) -> V(0) N(0) Z(0) C(0) A(0x16)
+H(1) C(1) A(0x10) -> V(0) N(0) Z(0) C(1) A(0x76)
+
+H(0) C(0) A(0x11) -> V(0) N(0) Z(0) C(0) A(0x11)
+H(0) C(1) A(0x11) -> V(0) N(0) Z(0) C(1) A(0x71)
+H(1) C(0) A(0x11) -> V(0) N(0) Z(0) C(0) A(0x17)
+H(1) C(1) A(0x11) -> V(0) N(0) Z(0) C(1) A(0x77)
+
+H(0) C(0) A(0x12) -> V(0) N(0) Z(0) C(0) A(0x12)
+H(0) C(1) A(0x12) -> V(0) N(0) Z(0) C(1) A(0x72)
+H(1) C(0) A(0x12) -> V(0) N(0) Z(0) C(0) A(0x18)
+H(1) C(1) A(0x12) -> V(0) N(0) Z(0) C(1) A(0x78)
+
+H(0) C(0) A(0x13) -> V(0) N(0) Z(0) C(0) A(0x13)
+H(0) C(1) A(0x13) -> V(0) N(0) Z(0) C(1) A(0x73)
+H(1) C(0) A(0x13) -> V(0) N(0) Z(0) C(0) A(0x19)
+H(1) C(1) A(0x13) -> V(0) N(0) Z(0) C(1) A(0x79)
+
+H(0) C(0) A(0x14) -> V(0) N(0) Z(0) C(0) A(0x14)
+H(0) C(1) A(0x14) -> V(0) N(0) Z(0) C(1) A(0x74)
+H(1) C(0) A(0x14) -> V(0) N(0) Z(0) C(0) A(0x1A)
+H(1) C(1) A(0x14) -> V(0) N(0) Z(0) C(1) A(0x7A)
+
+H(0) C(0) A(0x15) -> V(0) N(0) Z(0) C(0) A(0x15)
+H(0) C(1) A(0x15) -> V(0) N(0) Z(0) C(1) A(0x75)
+H(1) C(0) A(0x15) -> V(0) N(0) Z(0) C(0) A(0x1B)
+H(1) C(1) A(0x15) -> V(0) N(0) Z(0) C(1) A(0x7B)
+
+H(0) C(0) A(0x16) -> V(0) N(0) Z(0) C(0) A(0x16)
+H(0) C(1) A(0x16) -> V(0) N(0) Z(0) C(1) A(0x76)
+H(1) C(0) A(0x16) -> V(0) N(0) Z(0) C(0) A(0x1C)
+H(1) C(1) A(0x16) -> V(0) N(0) Z(0) C(1) A(0x7C)
+
+H(0) C(0) A(0x17) -> V(0) N(0) Z(0) C(0) A(0x17)
+H(0) C(1) A(0x17) -> V(0) N(0) Z(0) C(1) A(0x77)
+H(1) C(0) A(0x17) -> V(0) N(0) Z(0) C(0) A(0x1D)
+H(1) C(1) A(0x17) -> V(0) N(0) Z(0) C(1) A(0x7D)
+
+H(0) C(0) A(0x18) -> V(0) N(0) Z(0) C(0) A(0x18)
+H(0) C(1) A(0x18) -> V(0) N(0) Z(0) C(1) A(0x78)
+H(1) C(0) A(0x18) -> V(0) N(0) Z(0) C(0) A(0x1E)
+H(1) C(1) A(0x18) -> V(0) N(0) Z(0) C(1) A(0x7E)
+
+H(0) C(0) A(0x19) -> V(0) N(0) Z(0) C(0) A(0x19)
+H(0) C(1) A(0x19) -> V(0) N(0) Z(0) C(1) A(0x79)
+H(1) C(0) A(0x19) -> V(0) N(0) Z(0) C(0) A(0x1F)
+H(1) C(1) A(0x19) -> V(0) N(0) Z(0) C(1) A(0x7F)
+
+H(0) C(0) A(0x1A) -> V(0) N(0) Z(0) C(0) A(0x20)
+H(0) C(1) A(0x1A) -> V(1) N(1) Z(0) C(1) A(0x80)
+H(1) C(0) A(0x1A) -> V(0) N(0) Z(0) C(0) A(0x20)
+H(1) C(1) A(0x1A) -> V(1) N(1) Z(0) C(1) A(0x80)
+
+H(0) C(0) A(0x1B) -> V(0) N(0) Z(0) C(0) A(0x21)
+H(0) C(1) A(0x1B) -> V(1) N(1) Z(0) C(1) A(0x81)
+H(1) C(0) A(0x1B) -> V(0) N(0) Z(0) C(0) A(0x21)
+H(1) C(1) A(0x1B) -> V(1) N(1) Z(0) C(1) A(0x81)
+
+H(0) C(0) A(0x1C) -> V(0) N(0) Z(0) C(0) A(0x22)
+H(0) C(1) A(0x1C) -> V(1) N(1) Z(0) C(1) A(0x82)
+H(1) C(0) A(0x1C) -> V(0) N(0) Z(0) C(0) A(0x22)
+H(1) C(1) A(0x1C) -> V(1) N(1) Z(0) C(1) A(0x82)
+
+H(0) C(0) A(0x1D) -> V(0) N(0) Z(0) C(0) A(0x23)
+H(0) C(1) A(0x1D) -> V(1) N(1) Z(0) C(1) A(0x83)
+H(1) C(0) A(0x1D) -> V(0) N(0) Z(0) C(0) A(0x23)
+H(1) C(1) A(0x1D) -> V(1) N(1) Z(0) C(1) A(0x83)
+
+H(0) C(0) A(0x1E) -> V(0) N(0) Z(0) C(0) A(0x24)
+H(0) C(1) A(0x1E) -> V(1) N(1) Z(0) C(1) A(0x84)
+H(1) C(0) A(0x1E) -> V(0) N(0) Z(0) C(0) A(0x24)
+H(1) C(1) A(0x1E) -> V(1) N(1) Z(0) C(1) A(0x84)
+
+H(0) C(0) A(0x1F) -> V(0) N(0) Z(0) C(0) A(0x25)
+H(0) C(1) A(0x1F) -> V(1) N(1) Z(0) C(1) A(0x85)
+H(1) C(0) A(0x1F) -> V(0) N(0) Z(0) C(0) A(0x25)
+H(1) C(1) A(0x1F) -> V(1) N(1) Z(0) C(1) A(0x85)
+
+H(0) C(0) A(0x20) -> V(0) N(0) Z(0) C(0) A(0x20)
+H(0) C(1) A(0x20) -> V(1) N(1) Z(0) C(1) A(0x80)
+H(1) C(0) A(0x20) -> V(0) N(0) Z(0) C(0) A(0x26)
+H(1) C(1) A(0x20) -> V(1) N(1) Z(0) C(1) A(0x86)
+
+H(0) C(0) A(0x21) -> V(0) N(0) Z(0) C(0) A(0x21)
+H(0) C(1) A(0x21) -> V(1) N(1) Z(0) C(1) A(0x81)
+H(1) C(0) A(0x21) -> V(0) N(0) Z(0) C(0) A(0x27)
+H(1) C(1) A(0x21) -> V(1) N(1) Z(0) C(1) A(0x87)
+
+H(0) C(0) A(0x22) -> V(0) N(0) Z(0) C(0) A(0x22)
+H(0) C(1) A(0x22) -> V(1) N(1) Z(0) C(1) A(0x82)
+H(1) C(0) A(0x22) -> V(0) N(0) Z(0) C(0) A(0x28)
+H(1) C(1) A(0x22) -> V(1) N(1) Z(0) C(1) A(0x88)
+
+H(0) C(0) A(0x23) -> V(0) N(0) Z(0) C(0) A(0x23)
+H(0) C(1) A(0x23) -> V(1) N(1) Z(0) C(1) A(0x83)
+H(1) C(0) A(0x23) -> V(0) N(0) Z(0) C(0) A(0x29)
+H(1) C(1) A(0x23) -> V(1) N(1) Z(0) C(1) A(0x89)
+
+H(0) C(0) A(0x24) -> V(0) N(0) Z(0) C(0) A(0x24)
+H(0) C(1) A(0x24) -> V(1) N(1) Z(0) C(1) A(0x84)
+H(1) C(0) A(0x24) -> V(0) N(0) Z(0) C(0) A(0x2A)
+H(1) C(1) A(0x24) -> V(1) N(1) Z(0) C(1) A(0x8A)
+
+H(0) C(0) A(0x25) -> V(0) N(0) Z(0) C(0) A(0x25)
+H(0) C(1) A(0x25) -> V(1) N(1) Z(0) C(1) A(0x85)
+H(1) C(0) A(0x25) -> V(0) N(0) Z(0) C(0) A(0x2B)
+H(1) C(1) A(0x25) -> V(1) N(1) Z(0) C(1) A(0x8B)
+
+H(0) C(0) A(0x26) -> V(0) N(0) Z(0) C(0) A(0x26)
+H(0) C(1) A(0x26) -> V(1) N(1) Z(0) C(1) A(0x86)
+H(1) C(0) A(0x26) -> V(0) N(0) Z(0) C(0) A(0x2C)
+H(1) C(1) A(0x26) -> V(1) N(1) Z(0) C(1) A(0x8C)
+
+H(0) C(0) A(0x27) -> V(0) N(0) Z(0) C(0) A(0x27)
+H(0) C(1) A(0x27) -> V(1) N(1) Z(0) C(1) A(0x87)
+H(1) C(0) A(0x27) -> V(0) N(0) Z(0) C(0) A(0x2D)
+H(1) C(1) A(0x27) -> V(1) N(1) Z(0) C(1) A(0x8D)
+
+H(0) C(0) A(0x28) -> V(0) N(0) Z(0) C(0) A(0x28)
+H(0) C(1) A(0x28) -> V(1) N(1) Z(0) C(1) A(0x88)
+H(1) C(0) A(0x28) -> V(0) N(0) Z(0) C(0) A(0x2E)
+H(1) C(1) A(0x28) -> V(1) N(1) Z(0) C(1) A(0x8E)
+
+H(0) C(0) A(0x29) -> V(0) N(0) Z(0) C(0) A(0x29)
+H(0) C(1) A(0x29) -> V(1) N(1) Z(0) C(1) A(0x89)
+H(1) C(0) A(0x29) -> V(0) N(0) Z(0) C(0) A(0x2F)
+H(1) C(1) A(0x29) -> V(1) N(1) Z(0) C(1) A(0x8F)
+
+H(0) C(0) A(0x2A) -> V(0) N(0) Z(0) C(0) A(0x30)
+H(0) C(1) A(0x2A) -> V(1) N(1) Z(0) C(1) A(0x90)
+H(1) C(0) A(0x2A) -> V(0) N(0) Z(0) C(0) A(0x30)
+H(1) C(1) A(0x2A) -> V(1) N(1) Z(0) C(1) A(0x90)
+
+H(0) C(0) A(0x2B) -> V(0) N(0) Z(0) C(0) A(0x31)
+H(0) C(1) A(0x2B) -> V(1) N(1) Z(0) C(1) A(0x91)
+H(1) C(0) A(0x2B) -> V(0) N(0) Z(0) C(0) A(0x31)
+H(1) C(1) A(0x2B) -> V(1) N(1) Z(0) C(1) A(0x91)
+
+H(0) C(0) A(0x2C) -> V(0) N(0) Z(0) C(0) A(0x32)
+H(0) C(1) A(0x2C) -> V(1) N(1) Z(0) C(1) A(0x92)
+H(1) C(0) A(0x2C) -> V(0) N(0) Z(0) C(0) A(0x32)
+H(1) C(1) A(0x2C) -> V(1) N(1) Z(0) C(1) A(0x92)
+
+H(0) C(0) A(0x2D) -> V(0) N(0) Z(0) C(0) A(0x33)
+H(0) C(1) A(0x2D) -> V(1) N(1) Z(0) C(1) A(0x93)
+H(1) C(0) A(0x2D) -> V(0) N(0) Z(0) C(0) A(0x33)
+H(1) C(1) A(0x2D) -> V(1) N(1) Z(0) C(1) A(0x93)
+
+H(0) C(0) A(0x2E) -> V(0) N(0) Z(0) C(0) A(0x34)
+H(0) C(1) A(0x2E) -> V(1) N(1) Z(0) C(1) A(0x94)
+H(1) C(0) A(0x2E) -> V(0) N(0) Z(0) C(0) A(0x34)
+H(1) C(1) A(0x2E) -> V(1) N(1) Z(0) C(1) A(0x94)
+
+H(0) C(0) A(0x2F) -> V(0) N(0) Z(0) C(0) A(0x35)
+H(0) C(1) A(0x2F) -> V(1) N(1) Z(0) C(1) A(0x95)
+H(1) C(0) A(0x2F) -> V(0) N(0) Z(0) C(0) A(0x35)
+H(1) C(1) A(0x2F) -> V(1) N(1) Z(0) C(1) A(0x95)
+
+H(0) C(0) A(0x30) -> V(0) N(0) Z(0) C(0) A(0x30)
+H(0) C(1) A(0x30) -> V(1) N(1) Z(0) C(1) A(0x90)
+H(1) C(0) A(0x30) -> V(0) N(0) Z(0) C(0) A(0x36)
+H(1) C(1) A(0x30) -> V(1) N(1) Z(0) C(1) A(0x96)
+
+H(0) C(0) A(0x31) -> V(0) N(0) Z(0) C(0) A(0x31)
+H(0) C(1) A(0x31) -> V(1) N(1) Z(0) C(1) A(0x91)
+H(1) C(0) A(0x31) -> V(0) N(0) Z(0) C(0) A(0x37)
+H(1) C(1) A(0x31) -> V(1) N(1) Z(0) C(1) A(0x97)
+
+H(0) C(0) A(0x32) -> V(0) N(0) Z(0) C(0) A(0x32)
+H(0) C(1) A(0x32) -> V(1) N(1) Z(0) C(1) A(0x92)
+H(1) C(0) A(0x32) -> V(0) N(0) Z(0) C(0) A(0x38)
+H(1) C(1) A(0x32) -> V(1) N(1) Z(0) C(1) A(0x98)
+
+H(0) C(0) A(0x33) -> V(0) N(0) Z(0) C(0) A(0x33)
+H(0) C(1) A(0x33) -> V(1) N(1) Z(0) C(1) A(0x93)
+H(1) C(0) A(0x33) -> V(0) N(0) Z(0) C(0) A(0x39)
+H(1) C(1) A(0x33) -> V(1) N(1) Z(0) C(1) A(0x99)
+
+H(0) C(0) A(0x34) -> V(0) N(0) Z(0) C(0) A(0x34)
+H(0) C(1) A(0x34) -> V(1) N(1) Z(0) C(1) A(0x94)
+H(1) C(0) A(0x34) -> V(0) N(0) Z(0) C(0) A(0x3A)
+H(1) C(1) A(0x34) -> V(1) N(1) Z(0) C(1) A(0x9A)
+
+H(0) C(0) A(0x35) -> V(0) N(0) Z(0) C(0) A(0x35)
+H(0) C(1) A(0x35) -> V(1) N(1) Z(0) C(1) A(0x95)
+H(1) C(0) A(0x35) -> V(0) N(0) Z(0) C(0) A(0x3B)
+H(1) C(1) A(0x35) -> V(1) N(1) Z(0) C(1) A(0x9B)
+
+H(0) C(0) A(0x36) -> V(0) N(0) Z(0) C(0) A(0x36)
+H(0) C(1) A(0x36) -> V(1) N(1) Z(0) C(1) A(0x96)
+H(1) C(0) A(0x36) -> V(0) N(0) Z(0) C(0) A(0x3C)
+H(1) C(1) A(0x36) -> V(1) N(1) Z(0) C(1) A(0x9C)
+
+H(0) C(0) A(0x37) -> V(0) N(0) Z(0) C(0) A(0x37)
+H(0) C(1) A(0x37) -> V(1) N(1) Z(0) C(1) A(0x97)
+H(1) C(0) A(0x37) -> V(0) N(0) Z(0) C(0) A(0x3D)
+H(1) C(1) A(0x37) -> V(1) N(1) Z(0) C(1) A(0x9D)
+
+H(0) C(0) A(0x38) -> V(0) N(0) Z(0) C(0) A(0x38)
+H(0) C(1) A(0x38) -> V(1) N(1) Z(0) C(1) A(0x98)
+H(1) C(0) A(0x38) -> V(0) N(0) Z(0) C(0) A(0x3E)
+H(1) C(1) A(0x38) -> V(1) N(1) Z(0) C(1) A(0x9E)
+
+H(0) C(0) A(0x39) -> V(0) N(0) Z(0) C(0) A(0x39)
+H(0) C(1) A(0x39) -> V(1) N(1) Z(0) C(1) A(0x99)
+H(1) C(0) A(0x39) -> V(0) N(0) Z(0) C(0) A(0x3F)
+H(1) C(1) A(0x39) -> V(1) N(1) Z(0) C(1) A(0x9F)
+
+H(0) C(0) A(0x3A) -> V(0) N(0) Z(0) C(0) A(0x40)
+H(0) C(1) A(0x3A) -> V(1) N(1) Z(0) C(1) A(0xA0)
+H(1) C(0) A(0x3A) -> V(0) N(0) Z(0) C(0) A(0x40)
+H(1) C(1) A(0x3A) -> V(1) N(1) Z(0) C(1) A(0xA0)
+
+H(0) C(0) A(0x3B) -> V(0) N(0) Z(0) C(0) A(0x41)
+H(0) C(1) A(0x3B) -> V(1) N(1) Z(0) C(1) A(0xA1)
+H(1) C(0) A(0x3B) -> V(0) N(0) Z(0) C(0) A(0x41)
+H(1) C(1) A(0x3B) -> V(1) N(1) Z(0) C(1) A(0xA1)
+
+H(0) C(0) A(0x3C) -> V(0) N(0) Z(0) C(0) A(0x42)
+H(0) C(1) A(0x3C) -> V(1) N(1) Z(0) C(1) A(0xA2)
+H(1) C(0) A(0x3C) -> V(0) N(0) Z(0) C(0) A(0x42)
+H(1) C(1) A(0x3C) -> V(1) N(1) Z(0) C(1) A(0xA2)
+
+H(0) C(0) A(0x3D) -> V(0) N(0) Z(0) C(0) A(0x43)
+H(0) C(1) A(0x3D) -> V(1) N(1) Z(0) C(1) A(0xA3)
+H(1) C(0) A(0x3D) -> V(0) N(0) Z(0) C(0) A(0x43)
+H(1) C(1) A(0x3D) -> V(1) N(1) Z(0) C(1) A(0xA3)
+
+H(0) C(0) A(0x3E) -> V(0) N(0) Z(0) C(0) A(0x44)
+H(0) C(1) A(0x3E) -> V(1) N(1) Z(0) C(1) A(0xA4)
+H(1) C(0) A(0x3E) -> V(0) N(0) Z(0) C(0) A(0x44)
+H(1) C(1) A(0x3E) -> V(1) N(1) Z(0) C(1) A(0xA4)
+
+H(0) C(0) A(0x3F) -> V(0) N(0) Z(0) C(0) A(0x45)
+H(0) C(1) A(0x3F) -> V(1) N(1) Z(0) C(1) A(0xA5)
+H(1) C(0) A(0x3F) -> V(0) N(0) Z(0) C(0) A(0x45)
+H(1) C(1) A(0x3F) -> V(1) N(1) Z(0) C(1) A(0xA5)
+
+H(0) C(0) A(0x40) -> V(0) N(0) Z(0) C(0) A(0x40)
+H(0) C(1) A(0x40) -> V(1) N(1) Z(0) C(1) A(0xA0)
+H(1) C(0) A(0x40) -> V(0) N(0) Z(0) C(0) A(0x46)
+H(1) C(1) A(0x40) -> V(1) N(1) Z(0) C(1) A(0xA6)
+
+H(0) C(0) A(0x41) -> V(0) N(0) Z(0) C(0) A(0x41)
+H(0) C(1) A(0x41) -> V(1) N(1) Z(0) C(1) A(0xA1)
+H(1) C(0) A(0x41) -> V(0) N(0) Z(0) C(0) A(0x47)
+H(1) C(1) A(0x41) -> V(1) N(1) Z(0) C(1) A(0xA7)
+
+H(0) C(0) A(0x42) -> V(0) N(0) Z(0) C(0) A(0x42)
+H(0) C(1) A(0x42) -> V(1) N(1) Z(0) C(1) A(0xA2)
+H(1) C(0) A(0x42) -> V(0) N(0) Z(0) C(0) A(0x48)
+H(1) C(1) A(0x42) -> V(1) N(1) Z(0) C(1) A(0xA8)
+
+H(0) C(0) A(0x43) -> V(0) N(0) Z(0) C(0) A(0x43)
+H(0) C(1) A(0x43) -> V(1) N(1) Z(0) C(1) A(0xA3)
+H(1) C(0) A(0x43) -> V(0) N(0) Z(0) C(0) A(0x49)
+H(1) C(1) A(0x43) -> V(1) N(1) Z(0) C(1) A(0xA9)
+
+H(0) C(0) A(0x44) -> V(0) N(0) Z(0) C(0) A(0x44)
+H(0) C(1) A(0x44) -> V(1) N(1) Z(0) C(1) A(0xA4)
+H(1) C(0) A(0x44) -> V(0) N(0) Z(0) C(0) A(0x4A)
+H(1) C(1) A(0x44) -> V(1) N(1) Z(0) C(1) A(0xAA)
+
+H(0) C(0) A(0x45) -> V(0) N(0) Z(0) C(0) A(0x45)
+H(0) C(1) A(0x45) -> V(1) N(1) Z(0) C(1) A(0xA5)
+H(1) C(0) A(0x45) -> V(0) N(0) Z(0) C(0) A(0x4B)
+H(1) C(1) A(0x45) -> V(1) N(1) Z(0) C(1) A(0xAB)
+
+H(0) C(0) A(0x46) -> V(0) N(0) Z(0) C(0) A(0x46)
+H(0) C(1) A(0x46) -> V(1) N(1) Z(0) C(1) A(0xA6)
+H(1) C(0) A(0x46) -> V(0) N(0) Z(0) C(0) A(0x4C)
+H(1) C(1) A(0x46) -> V(1) N(1) Z(0) C(1) A(0xAC)
+
+H(0) C(0) A(0x47) -> V(0) N(0) Z(0) C(0) A(0x47)
+H(0) C(1) A(0x47) -> V(1) N(1) Z(0) C(1) A(0xA7)
+H(1) C(0) A(0x47) -> V(0) N(0) Z(0) C(0) A(0x4D)
+H(1) C(1) A(0x47) -> V(1) N(1) Z(0) C(1) A(0xAD)
+
+H(0) C(0) A(0x48) -> V(0) N(0) Z(0) C(0) A(0x48)
+H(0) C(1) A(0x48) -> V(1) N(1) Z(0) C(1) A(0xA8)
+H(1) C(0) A(0x48) -> V(0) N(0) Z(0) C(0) A(0x4E)
+H(1) C(1) A(0x48) -> V(1) N(1) Z(0) C(1) A(0xAE)
+
+H(0) C(0) A(0x49) -> V(0) N(0) Z(0) C(0) A(0x49)
+H(0) C(1) A(0x49) -> V(1) N(1) Z(0) C(1) A(0xA9)
+H(1) C(0) A(0x49) -> V(0) N(0) Z(0) C(0) A(0x4F)
+H(1) C(1) A(0x49) -> V(1) N(1) Z(0) C(1) A(0xAF)
+
+H(0) C(0) A(0x4A) -> V(0) N(0) Z(0) C(0) A(0x50)
+H(0) C(1) A(0x4A) -> V(1) N(1) Z(0) C(1) A(0xB0)
+H(1) C(0) A(0x4A) -> V(0) N(0) Z(0) C(0) A(0x50)
+H(1) C(1) A(0x4A) -> V(1) N(1) Z(0) C(1) A(0xB0)
+
+H(0) C(0) A(0x4B) -> V(0) N(0) Z(0) C(0) A(0x51)
+H(0) C(1) A(0x4B) -> V(1) N(1) Z(0) C(1) A(0xB1)
+H(1) C(0) A(0x4B) -> V(0) N(0) Z(0) C(0) A(0x51)
+H(1) C(1) A(0x4B) -> V(1) N(1) Z(0) C(1) A(0xB1)
+
+H(0) C(0) A(0x4C) -> V(0) N(0) Z(0) C(0) A(0x52)
+H(0) C(1) A(0x4C) -> V(1) N(1) Z(0) C(1) A(0xB2)
+H(1) C(0) A(0x4C) -> V(0) N(0) Z(0) C(0) A(0x52)
+H(1) C(1) A(0x4C) -> V(1) N(1) Z(0) C(1) A(0xB2)
+
+H(0) C(0) A(0x4D) -> V(0) N(0) Z(0) C(0) A(0x53)
+H(0) C(1) A(0x4D) -> V(1) N(1) Z(0) C(1) A(0xB3)
+H(1) C(0) A(0x4D) -> V(0) N(0) Z(0) C(0) A(0x53)
+H(1) C(1) A(0x4D) -> V(1) N(1) Z(0) C(1) A(0xB3)
+
+H(0) C(0) A(0x4E) -> V(0) N(0) Z(0) C(0) A(0x54)
+H(0) C(1) A(0x4E) -> V(1) N(1) Z(0) C(1) A(0xB4)
+H(1) C(0) A(0x4E) -> V(0) N(0) Z(0) C(0) A(0x54)
+H(1) C(1) A(0x4E) -> V(1) N(1) Z(0) C(1) A(0xB4)
+
+H(0) C(0) A(0x4F) -> V(0) N(0) Z(0) C(0) A(0x55)
+H(0) C(1) A(0x4F) -> V(1) N(1) Z(0) C(1) A(0xB5)
+H(1) C(0) A(0x4F) -> V(0) N(0) Z(0) C(0) A(0x55)
+H(1) C(1) A(0x4F) -> V(1) N(1) Z(0) C(1) A(0xB5)
+
+H(0) C(0) A(0x50) -> V(0) N(0) Z(0) C(0) A(0x50)
+H(0) C(1) A(0x50) -> V(1) N(1) Z(0) C(1) A(0xB0)
+H(1) C(0) A(0x50) -> V(0) N(0) Z(0) C(0) A(0x56)
+H(1) C(1) A(0x50) -> V(1) N(1) Z(0) C(1) A(0xB6)
+
+H(0) C(0) A(0x51) -> V(0) N(0) Z(0) C(0) A(0x51)
+H(0) C(1) A(0x51) -> V(1) N(1) Z(0) C(1) A(0xB1)
+H(1) C(0) A(0x51) -> V(0) N(0) Z(0) C(0) A(0x57)
+H(1) C(1) A(0x51) -> V(1) N(1) Z(0) C(1) A(0xB7)
+
+H(0) C(0) A(0x52) -> V(0) N(0) Z(0) C(0) A(0x52)
+H(0) C(1) A(0x52) -> V(1) N(1) Z(0) C(1) A(0xB2)
+H(1) C(0) A(0x52) -> V(0) N(0) Z(0) C(0) A(0x58)
+H(1) C(1) A(0x52) -> V(1) N(1) Z(0) C(1) A(0xB8)
+
+H(0) C(0) A(0x53) -> V(0) N(0) Z(0) C(0) A(0x53)
+H(0) C(1) A(0x53) -> V(1) N(1) Z(0) C(1) A(0xB3)
+H(1) C(0) A(0x53) -> V(0) N(0) Z(0) C(0) A(0x59)
+H(1) C(1) A(0x53) -> V(1) N(1) Z(0) C(1) A(0xB9)
+
+H(0) C(0) A(0x54) -> V(0) N(0) Z(0) C(0) A(0x54)
+H(0) C(1) A(0x54) -> V(1) N(1) Z(0) C(1) A(0xB4)
+H(1) C(0) A(0x54) -> V(0) N(0) Z(0) C(0) A(0x5A)
+H(1) C(1) A(0x54) -> V(1) N(1) Z(0) C(1) A(0xBA)
+
+H(0) C(0) A(0x55) -> V(0) N(0) Z(0) C(0) A(0x55)
+H(0) C(1) A(0x55) -> V(1) N(1) Z(0) C(1) A(0xB5)
+H(1) C(0) A(0x55) -> V(0) N(0) Z(0) C(0) A(0x5B)
+H(1) C(1) A(0x55) -> V(1) N(1) Z(0) C(1) A(0xBB)
+
+H(0) C(0) A(0x56) -> V(0) N(0) Z(0) C(0) A(0x56)
+H(0) C(1) A(0x56) -> V(1) N(1) Z(0) C(1) A(0xB6)
+H(1) C(0) A(0x56) -> V(0) N(0) Z(0) C(0) A(0x5C)
+H(1) C(1) A(0x56) -> V(1) N(1) Z(0) C(1) A(0xBC)
+
+H(0) C(0) A(0x57) -> V(0) N(0) Z(0) C(0) A(0x57)
+H(0) C(1) A(0x57) -> V(1) N(1) Z(0) C(1) A(0xB7)
+H(1) C(0) A(0x57) -> V(0) N(0) Z(0) C(0) A(0x5D)
+H(1) C(1) A(0x57) -> V(1) N(1) Z(0) C(1) A(0xBD)
+
+H(0) C(0) A(0x58) -> V(0) N(0) Z(0) C(0) A(0x58)
+H(0) C(1) A(0x58) -> V(1) N(1) Z(0) C(1) A(0xB8)
+H(1) C(0) A(0x58) -> V(0) N(0) Z(0) C(0) A(0x5E)
+H(1) C(1) A(0x58) -> V(1) N(1) Z(0) C(1) A(0xBE)
+
+H(0) C(0) A(0x59) -> V(0) N(0) Z(0) C(0) A(0x59)
+H(0) C(1) A(0x59) -> V(1) N(1) Z(0) C(1) A(0xB9)
+H(1) C(0) A(0x59) -> V(0) N(0) Z(0) C(0) A(0x5F)
+H(1) C(1) A(0x59) -> V(1) N(1) Z(0) C(1) A(0xBF)
+
+H(0) C(0) A(0x5A) -> V(0) N(0) Z(0) C(0) A(0x60)
+H(0) C(1) A(0x5A) -> V(1) N(1) Z(0) C(1) A(0xC0)
+H(1) C(0) A(0x5A) -> V(0) N(0) Z(0) C(0) A(0x60)
+H(1) C(1) A(0x5A) -> V(1) N(1) Z(0) C(1) A(0xC0)
+
+H(0) C(0) A(0x5B) -> V(0) N(0) Z(0) C(0) A(0x61)
+H(0) C(1) A(0x5B) -> V(1) N(1) Z(0) C(1) A(0xC1)
+H(1) C(0) A(0x5B) -> V(0) N(0) Z(0) C(0) A(0x61)
+H(1) C(1) A(0x5B) -> V(1) N(1) Z(0) C(1) A(0xC1)
+
+H(0) C(0) A(0x5C) -> V(0) N(0) Z(0) C(0) A(0x62)
+H(0) C(1) A(0x5C) -> V(1) N(1) Z(0) C(1) A(0xC2)
+H(1) C(0) A(0x5C) -> V(0) N(0) Z(0) C(0) A(0x62)
+H(1) C(1) A(0x5C) -> V(1) N(1) Z(0) C(1) A(0xC2)
+
+H(0) C(0) A(0x5D) -> V(0) N(0) Z(0) C(0) A(0x63)
+H(0) C(1) A(0x5D) -> V(1) N(1) Z(0) C(1) A(0xC3)
+H(1) C(0) A(0x5D) -> V(0) N(0) Z(0) C(0) A(0x63)
+H(1) C(1) A(0x5D) -> V(1) N(1) Z(0) C(1) A(0xC3)
+
+H(0) C(0) A(0x5E) -> V(0) N(0) Z(0) C(0) A(0x64)
+H(0) C(1) A(0x5E) -> V(1) N(1) Z(0) C(1) A(0xC4)
+H(1) C(0) A(0x5E) -> V(0) N(0) Z(0) C(0) A(0x64)
+H(1) C(1) A(0x5E) -> V(1) N(1) Z(0) C(1) A(0xC4)
+
+H(0) C(0) A(0x5F) -> V(0) N(0) Z(0) C(0) A(0x65)
+H(0) C(1) A(0x5F) -> V(1) N(1) Z(0) C(1) A(0xC5)
+H(1) C(0) A(0x5F) -> V(0) N(0) Z(0) C(0) A(0x65)
+H(1) C(1) A(0x5F) -> V(1) N(1) Z(0) C(1) A(0xC5)
+
+H(0) C(0) A(0x60) -> V(0) N(0) Z(0) C(0) A(0x60)
+H(0) C(1) A(0x60) -> V(1) N(1) Z(0) C(1) A(0xC0)
+H(1) C(0) A(0x60) -> V(0) N(0) Z(0) C(0) A(0x66)
+H(1) C(1) A(0x60) -> V(1) N(1) Z(0) C(1) A(0xC6)
+
+H(0) C(0) A(0x61) -> V(0) N(0) Z(0) C(0) A(0x61)
+H(0) C(1) A(0x61) -> V(1) N(1) Z(0) C(1) A(0xC1)
+H(1) C(0) A(0x61) -> V(0) N(0) Z(0) C(0) A(0x67)
+H(1) C(1) A(0x61) -> V(1) N(1) Z(0) C(1) A(0xC7)
+
+H(0) C(0) A(0x62) -> V(0) N(0) Z(0) C(0) A(0x62)
+H(0) C(1) A(0x62) -> V(1) N(1) Z(0) C(1) A(0xC2)
+H(1) C(0) A(0x62) -> V(0) N(0) Z(0) C(0) A(0x68)
+H(1) C(1) A(0x62) -> V(1) N(1) Z(0) C(1) A(0xC8)
+
+H(0) C(0) A(0x63) -> V(0) N(0) Z(0) C(0) A(0x63)
+H(0) C(1) A(0x63) -> V(1) N(1) Z(0) C(1) A(0xC3)
+H(1) C(0) A(0x63) -> V(0) N(0) Z(0) C(0) A(0x69)
+H(1) C(1) A(0x63) -> V(1) N(1) Z(0) C(1) A(0xC9)
+
+H(0) C(0) A(0x64) -> V(0) N(0) Z(0) C(0) A(0x64)
+H(0) C(1) A(0x64) -> V(1) N(1) Z(0) C(1) A(0xC4)
+H(1) C(0) A(0x64) -> V(0) N(0) Z(0) C(0) A(0x6A)
+H(1) C(1) A(0x64) -> V(1) N(1) Z(0) C(1) A(0xCA)
+
+H(0) C(0) A(0x65) -> V(0) N(0) Z(0) C(0) A(0x65)
+H(0) C(1) A(0x65) -> V(1) N(1) Z(0) C(1) A(0xC5)
+H(1) C(0) A(0x65) -> V(0) N(0) Z(0) C(0) A(0x6B)
+H(1) C(1) A(0x65) -> V(1) N(1) Z(0) C(1) A(0xCB)
+
+H(0) C(0) A(0x66) -> V(0) N(0) Z(0) C(0) A(0x66)
+H(0) C(1) A(0x66) -> V(1) N(1) Z(0) C(1) A(0xC6)
+H(1) C(0) A(0x66) -> V(0) N(0) Z(0) C(0) A(0x6C)
+H(1) C(1) A(0x66) -> V(1) N(1) Z(0) C(1) A(0xCC)
+
+H(0) C(0) A(0x67) -> V(0) N(0) Z(0) C(0) A(0x67)
+H(0) C(1) A(0x67) -> V(1) N(1) Z(0) C(1) A(0xC7)
+H(1) C(0) A(0x67) -> V(0) N(0) Z(0) C(0) A(0x6D)
+H(1) C(1) A(0x67) -> V(1) N(1) Z(0) C(1) A(0xCD)
+
+H(0) C(0) A(0x68) -> V(0) N(0) Z(0) C(0) A(0x68)
+H(0) C(1) A(0x68) -> V(1) N(1) Z(0) C(1) A(0xC8)
+H(1) C(0) A(0x68) -> V(0) N(0) Z(0) C(0) A(0x6E)
+H(1) C(1) A(0x68) -> V(1) N(1) Z(0) C(1) A(0xCE)
+
+H(0) C(0) A(0x69) -> V(0) N(0) Z(0) C(0) A(0x69)
+H(0) C(1) A(0x69) -> V(1) N(1) Z(0) C(1) A(0xC9)
+H(1) C(0) A(0x69) -> V(0) N(0) Z(0) C(0) A(0x6F)
+H(1) C(1) A(0x69) -> V(1) N(1) Z(0) C(1) A(0xCF)
+
+H(0) C(0) A(0x6A) -> V(0) N(0) Z(0) C(0) A(0x70)
+H(0) C(1) A(0x6A) -> V(1) N(1) Z(0) C(1) A(0xD0)
+H(1) C(0) A(0x6A) -> V(0) N(0) Z(0) C(0) A(0x70)
+H(1) C(1) A(0x6A) -> V(1) N(1) Z(0) C(1) A(0xD0)
+
+H(0) C(0) A(0x6B) -> V(0) N(0) Z(0) C(0) A(0x71)
+H(0) C(1) A(0x6B) -> V(1) N(1) Z(0) C(1) A(0xD1)
+H(1) C(0) A(0x6B) -> V(0) N(0) Z(0) C(0) A(0x71)
+H(1) C(1) A(0x6B) -> V(1) N(1) Z(0) C(1) A(0xD1)
+
+H(0) C(0) A(0x6C) -> V(0) N(0) Z(0) C(0) A(0x72)
+H(0) C(1) A(0x6C) -> V(1) N(1) Z(0) C(1) A(0xD2)
+H(1) C(0) A(0x6C) -> V(0) N(0) Z(0) C(0) A(0x72)
+H(1) C(1) A(0x6C) -> V(1) N(1) Z(0) C(1) A(0xD2)
+
+H(0) C(0) A(0x6D) -> V(0) N(0) Z(0) C(0) A(0x73)
+H(0) C(1) A(0x6D) -> V(1) N(1) Z(0) C(1) A(0xD3)
+H(1) C(0) A(0x6D) -> V(0) N(0) Z(0) C(0) A(0x73)
+H(1) C(1) A(0x6D) -> V(1) N(1) Z(0) C(1) A(0xD3)
+
+H(0) C(0) A(0x6E) -> V(0) N(0) Z(0) C(0) A(0x74)
+H(0) C(1) A(0x6E) -> V(1) N(1) Z(0) C(1) A(0xD4)
+H(1) C(0) A(0x6E) -> V(0) N(0) Z(0) C(0) A(0x74)
+H(1) C(1) A(0x6E) -> V(1) N(1) Z(0) C(1) A(0xD4)
+
+H(0) C(0) A(0x6F) -> V(0) N(0) Z(0) C(0) A(0x75)
+H(0) C(1) A(0x6F) -> V(1) N(1) Z(0) C(1) A(0xD5)
+H(1) C(0) A(0x6F) -> V(0) N(0) Z(0) C(0) A(0x75)
+H(1) C(1) A(0x6F) -> V(1) N(1) Z(0) C(1) A(0xD5)
+
+H(0) C(0) A(0x70) -> V(0) N(0) Z(0) C(0) A(0x70)
+H(0) C(1) A(0x70) -> V(1) N(1) Z(0) C(1) A(0xD0)
+H(1) C(0) A(0x70) -> V(0) N(0) Z(0) C(0) A(0x76)
+H(1) C(1) A(0x70) -> V(1) N(1) Z(0) C(1) A(0xD6)
+
+H(0) C(0) A(0x71) -> V(0) N(0) Z(0) C(0) A(0x71)
+H(0) C(1) A(0x71) -> V(1) N(1) Z(0) C(1) A(0xD1)
+H(1) C(0) A(0x71) -> V(0) N(0) Z(0) C(0) A(0x77)
+H(1) C(1) A(0x71) -> V(1) N(1) Z(0) C(1) A(0xD7)
+
+H(0) C(0) A(0x72) -> V(0) N(0) Z(0) C(0) A(0x72)
+H(0) C(1) A(0x72) -> V(1) N(1) Z(0) C(1) A(0xD2)
+H(1) C(0) A(0x72) -> V(0) N(0) Z(0) C(0) A(0x78)
+H(1) C(1) A(0x72) -> V(1) N(1) Z(0) C(1) A(0xD8)
+
+H(0) C(0) A(0x73) -> V(0) N(0) Z(0) C(0) A(0x73)
+H(0) C(1) A(0x73) -> V(1) N(1) Z(0) C(1) A(0xD3)
+H(1) C(0) A(0x73) -> V(0) N(0) Z(0) C(0) A(0x79)
+H(1) C(1) A(0x73) -> V(1) N(1) Z(0) C(1) A(0xD9)
+
+H(0) C(0) A(0x74) -> V(0) N(0) Z(0) C(0) A(0x74)
+H(0) C(1) A(0x74) -> V(1) N(1) Z(0) C(1) A(0xD4)
+H(1) C(0) A(0x74) -> V(0) N(0) Z(0) C(0) A(0x7A)
+H(1) C(1) A(0x74) -> V(1) N(1) Z(0) C(1) A(0xDA)
+
+H(0) C(0) A(0x75) -> V(0) N(0) Z(0) C(0) A(0x75)
+H(0) C(1) A(0x75) -> V(1) N(1) Z(0) C(1) A(0xD5)
+H(1) C(0) A(0x75) -> V(0) N(0) Z(0) C(0) A(0x7B)
+H(1) C(1) A(0x75) -> V(1) N(1) Z(0) C(1) A(0xDB)
+
+H(0) C(0) A(0x76) -> V(0) N(0) Z(0) C(0) A(0x76)
+H(0) C(1) A(0x76) -> V(1) N(1) Z(0) C(1) A(0xD6)
+H(1) C(0) A(0x76) -> V(0) N(0) Z(0) C(0) A(0x7C)
+H(1) C(1) A(0x76) -> V(1) N(1) Z(0) C(1) A(0xDC)
+
+H(0) C(0) A(0x77) -> V(0) N(0) Z(0) C(0) A(0x77)
+H(0) C(1) A(0x77) -> V(1) N(1) Z(0) C(1) A(0xD7)
+H(1) C(0) A(0x77) -> V(0) N(0) Z(0) C(0) A(0x7D)
+H(1) C(1) A(0x77) -> V(1) N(1) Z(0) C(1) A(0xDD)
+
+H(0) C(0) A(0x78) -> V(0) N(0) Z(0) C(0) A(0x78)
+H(0) C(1) A(0x78) -> V(1) N(1) Z(0) C(1) A(0xD8)
+H(1) C(0) A(0x78) -> V(0) N(0) Z(0) C(0) A(0x7E)
+H(1) C(1) A(0x78) -> V(1) N(1) Z(0) C(1) A(0xDE)
+
+H(0) C(0) A(0x79) -> V(0) N(0) Z(0) C(0) A(0x79)
+H(0) C(1) A(0x79) -> V(1) N(1) Z(0) C(1) A(0xD9)
+H(1) C(0) A(0x79) -> V(0) N(0) Z(0) C(0) A(0x7F)
+H(1) C(1) A(0x79) -> V(1) N(1) Z(0) C(1) A(0xDF)
+
+H(0) C(0) A(0x7A) -> V(1) N(1) Z(0) C(0) A(0x80)
+H(0) C(1) A(0x7A) -> V(1) N(1) Z(0) C(1) A(0xE0)
+H(1) C(0) A(0x7A) -> V(1) N(1) Z(0) C(0) A(0x80)
+H(1) C(1) A(0x7A) -> V(1) N(1) Z(0) C(1) A(0xE0)
+
+H(0) C(0) A(0x7B) -> V(1) N(1) Z(0) C(0) A(0x81)
+H(0) C(1) A(0x7B) -> V(1) N(1) Z(0) C(1) A(0xE1)
+H(1) C(0) A(0x7B) -> V(1) N(1) Z(0) C(0) A(0x81)
+H(1) C(1) A(0x7B) -> V(1) N(1) Z(0) C(1) A(0xE1)
+
+H(0) C(0) A(0x7C) -> V(1) N(1) Z(0) C(0) A(0x82)
+H(0) C(1) A(0x7C) -> V(1) N(1) Z(0) C(1) A(0xE2)
+H(1) C(0) A(0x7C) -> V(1) N(1) Z(0) C(0) A(0x82)
+H(1) C(1) A(0x7C) -> V(1) N(1) Z(0) C(1) A(0xE2)
+
+H(0) C(0) A(0x7D) -> V(1) N(1) Z(0) C(0) A(0x83)
+H(0) C(1) A(0x7D) -> V(1) N(1) Z(0) C(1) A(0xE3)
+H(1) C(0) A(0x7D) -> V(1) N(1) Z(0) C(0) A(0x83)
+H(1) C(1) A(0x7D) -> V(1) N(1) Z(0) C(1) A(0xE3)
+
+H(0) C(0) A(0x7E) -> V(1) N(1) Z(0) C(0) A(0x84)
+H(0) C(1) A(0x7E) -> V(1) N(1) Z(0) C(1) A(0xE4)
+H(1) C(0) A(0x7E) -> V(1) N(1) Z(0) C(0) A(0x84)
+H(1) C(1) A(0x7E) -> V(1) N(1) Z(0) C(1) A(0xE4)
+
+H(0) C(0) A(0x7F) -> V(1) N(1) Z(0) C(0) A(0x85)
+H(0) C(1) A(0x7F) -> V(1) N(1) Z(0) C(1) A(0xE5)
+H(1) C(0) A(0x7F) -> V(1) N(1) Z(0) C(0) A(0x85)
+H(1) C(1) A(0x7F) -> V(1) N(1) Z(0) C(1) A(0xE5)
+
+H(0) C(0) A(0x80) -> V(0) N(1) Z(0) C(0) A(0x80)
+H(0) C(1) A(0x80) -> V(0) N(1) Z(0) C(1) A(0xE0)
+H(1) C(0) A(0x80) -> V(0) N(1) Z(0) C(0) A(0x86)
+H(1) C(1) A(0x80) -> V(0) N(1) Z(0) C(1) A(0xE6)
+
+H(0) C(0) A(0x81) -> V(0) N(1) Z(0) C(0) A(0x81)
+H(0) C(1) A(0x81) -> V(0) N(1) Z(0) C(1) A(0xE1)
+H(1) C(0) A(0x81) -> V(0) N(1) Z(0) C(0) A(0x87)
+H(1) C(1) A(0x81) -> V(0) N(1) Z(0) C(1) A(0xE7)
+
+H(0) C(0) A(0x82) -> V(0) N(1) Z(0) C(0) A(0x82)
+H(0) C(1) A(0x82) -> V(0) N(1) Z(0) C(1) A(0xE2)
+H(1) C(0) A(0x82) -> V(0) N(1) Z(0) C(0) A(0x88)
+H(1) C(1) A(0x82) -> V(0) N(1) Z(0) C(1) A(0xE8)
+
+H(0) C(0) A(0x83) -> V(0) N(1) Z(0) C(0) A(0x83)
+H(0) C(1) A(0x83) -> V(0) N(1) Z(0) C(1) A(0xE3)
+H(1) C(0) A(0x83) -> V(0) N(1) Z(0) C(0) A(0x89)
+H(1) C(1) A(0x83) -> V(0) N(1) Z(0) C(1) A(0xE9)
+
+H(0) C(0) A(0x84) -> V(0) N(1) Z(0) C(0) A(0x84)
+H(0) C(1) A(0x84) -> V(0) N(1) Z(0) C(1) A(0xE4)
+H(1) C(0) A(0x84) -> V(0) N(1) Z(0) C(0) A(0x8A)
+H(1) C(1) A(0x84) -> V(0) N(1) Z(0) C(1) A(0xEA)
+
+H(0) C(0) A(0x85) -> V(0) N(1) Z(0) C(0) A(0x85)
+H(0) C(1) A(0x85) -> V(0) N(1) Z(0) C(1) A(0xE5)
+H(1) C(0) A(0x85) -> V(0) N(1) Z(0) C(0) A(0x8B)
+H(1) C(1) A(0x85) -> V(0) N(1) Z(0) C(1) A(0xEB)
+
+H(0) C(0) A(0x86) -> V(0) N(1) Z(0) C(0) A(0x86)
+H(0) C(1) A(0x86) -> V(0) N(1) Z(0) C(1) A(0xE6)
+H(1) C(0) A(0x86) -> V(0) N(1) Z(0) C(0) A(0x8C)
+H(1) C(1) A(0x86) -> V(0) N(1) Z(0) C(1) A(0xEC)
+
+H(0) C(0) A(0x87) -> V(0) N(1) Z(0) C(0) A(0x87)
+H(0) C(1) A(0x87) -> V(0) N(1) Z(0) C(1) A(0xE7)
+H(1) C(0) A(0x87) -> V(0) N(1) Z(0) C(0) A(0x8D)
+H(1) C(1) A(0x87) -> V(0) N(1) Z(0) C(1) A(0xED)
+
+H(0) C(0) A(0x88) -> V(0) N(1) Z(0) C(0) A(0x88)
+H(0) C(1) A(0x88) -> V(0) N(1) Z(0) C(1) A(0xE8)
+H(1) C(0) A(0x88) -> V(0) N(1) Z(0) C(0) A(0x8E)
+H(1) C(1) A(0x88) -> V(0) N(1) Z(0) C(1) A(0xEE)
+
+H(0) C(0) A(0x89) -> V(0) N(1) Z(0) C(0) A(0x89)
+H(0) C(1) A(0x89) -> V(0) N(1) Z(0) C(1) A(0xE9)
+H(1) C(0) A(0x89) -> V(0) N(1) Z(0) C(0) A(0x8F)
+H(1) C(1) A(0x89) -> V(0) N(1) Z(0) C(1) A(0xEF)
+
+H(0) C(0) A(0x8A) -> V(0) N(1) Z(0) C(0) A(0x90)
+H(0) C(1) A(0x8A) -> V(0) N(1) Z(0) C(1) A(0xF0)
+H(1) C(0) A(0x8A) -> V(0) N(1) Z(0) C(0) A(0x90)
+H(1) C(1) A(0x8A) -> V(0) N(1) Z(0) C(1) A(0xF0)
+
+H(0) C(0) A(0x8B) -> V(0) N(1) Z(0) C(0) A(0x91)
+H(0) C(1) A(0x8B) -> V(0) N(1) Z(0) C(1) A(0xF1)
+H(1) C(0) A(0x8B) -> V(0) N(1) Z(0) C(0) A(0x91)
+H(1) C(1) A(0x8B) -> V(0) N(1) Z(0) C(1) A(0xF1)
+
+H(0) C(0) A(0x8C) -> V(0) N(1) Z(0) C(0) A(0x92)
+H(0) C(1) A(0x8C) -> V(0) N(1) Z(0) C(1) A(0xF2)
+H(1) C(0) A(0x8C) -> V(0) N(1) Z(0) C(0) A(0x92)
+H(1) C(1) A(0x8C) -> V(0) N(1) Z(0) C(1) A(0xF2)
+
+H(0) C(0) A(0x8D) -> V(0) N(1) Z(0) C(0) A(0x93)
+H(0) C(1) A(0x8D) -> V(0) N(1) Z(0) C(1) A(0xF3)
+H(1) C(0) A(0x8D) -> V(0) N(1) Z(0) C(0) A(0x93)
+H(1) C(1) A(0x8D) -> V(0) N(1) Z(0) C(1) A(0xF3)
+
+H(0) C(0) A(0x8E) -> V(0) N(1) Z(0) C(0) A(0x94)
+H(0) C(1) A(0x8E) -> V(0) N(1) Z(0) C(1) A(0xF4)
+H(1) C(0) A(0x8E) -> V(0) N(1) Z(0) C(0) A(0x94)
+H(1) C(1) A(0x8E) -> V(0) N(1) Z(0) C(1) A(0xF4)
+
+H(0) C(0) A(0x8F) -> V(0) N(1) Z(0) C(0) A(0x95)
+H(0) C(1) A(0x8F) -> V(0) N(1) Z(0) C(1) A(0xF5)
+H(1) C(0) A(0x8F) -> V(0) N(1) Z(0) C(0) A(0x95)
+H(1) C(1) A(0x8F) -> V(0) N(1) Z(0) C(1) A(0xF5)
+
+H(0) C(0) A(0x90) -> V(0) N(1) Z(0) C(0) A(0x90)
+H(0) C(1) A(0x90) -> V(0) N(1) Z(0) C(1) A(0xF0)
+H(1) C(0) A(0x90) -> V(0) N(1) Z(0) C(0) A(0x96)
+H(1) C(1) A(0x90) -> V(0) N(1) Z(0) C(1) A(0xF6)
+
+H(0) C(0) A(0x91) -> V(0) N(1) Z(0) C(0) A(0x91)
+H(0) C(1) A(0x91) -> V(0) N(1) Z(0) C(1) A(0xF1)
+H(1) C(0) A(0x91) -> V(0) N(1) Z(0) C(0) A(0x97)
+H(1) C(1) A(0x91) -> V(0) N(1) Z(0) C(1) A(0xF7)
+
+H(0) C(0) A(0x92) -> V(0) N(1) Z(0) C(0) A(0x92)
+H(0) C(1) A(0x92) -> V(0) N(1) Z(0) C(1) A(0xF2)
+H(1) C(0) A(0x92) -> V(0) N(1) Z(0) C(0) A(0x98)
+H(1) C(1) A(0x92) -> V(0) N(1) Z(0) C(1) A(0xF8)
+
+H(0) C(0) A(0x93) -> V(0) N(1) Z(0) C(0) A(0x93)
+H(0) C(1) A(0x93) -> V(0) N(1) Z(0) C(1) A(0xF3)
+H(1) C(0) A(0x93) -> V(0) N(1) Z(0) C(0) A(0x99)
+H(1) C(1) A(0x93) -> V(0) N(1) Z(0) C(1) A(0xF9)
+
+H(0) C(0) A(0x94) -> V(0) N(1) Z(0) C(0) A(0x94)
+H(0) C(1) A(0x94) -> V(0) N(1) Z(0) C(1) A(0xF4)
+H(1) C(0) A(0x94) -> V(0) N(1) Z(0) C(0) A(0x9A)
+H(1) C(1) A(0x94) -> V(0) N(1) Z(0) C(1) A(0xFA)
+
+H(0) C(0) A(0x95) -> V(0) N(1) Z(0) C(0) A(0x95)
+H(0) C(1) A(0x95) -> V(0) N(1) Z(0) C(1) A(0xF5)
+H(1) C(0) A(0x95) -> V(0) N(1) Z(0) C(0) A(0x9B)
+H(1) C(1) A(0x95) -> V(0) N(1) Z(0) C(1) A(0xFB)
+
+H(0) C(0) A(0x96) -> V(0) N(1) Z(0) C(0) A(0x96)
+H(0) C(1) A(0x96) -> V(0) N(1) Z(0) C(1) A(0xF6)
+H(1) C(0) A(0x96) -> V(0) N(1) Z(0) C(0) A(0x9C)
+H(1) C(1) A(0x96) -> V(0) N(1) Z(0) C(1) A(0xFC)
+
+H(0) C(0) A(0x97) -> V(0) N(1) Z(0) C(0) A(0x97)
+H(0) C(1) A(0x97) -> V(0) N(1) Z(0) C(1) A(0xF7)
+H(1) C(0) A(0x97) -> V(0) N(1) Z(0) C(0) A(0x9D)
+H(1) C(1) A(0x97) -> V(0) N(1) Z(0) C(1) A(0xFD)
+
+H(0) C(0) A(0x98) -> V(0) N(1) Z(0) C(0) A(0x98)
+H(0) C(1) A(0x98) -> V(0) N(1) Z(0) C(1) A(0xF8)
+H(1) C(0) A(0x98) -> V(0) N(1) Z(0) C(0) A(0x9E)
+H(1) C(1) A(0x98) -> V(0) N(1) Z(0) C(1) A(0xFE)
+
+H(0) C(0) A(0x99) -> V(0) N(1) Z(0) C(0) A(0x99)
+H(0) C(1) A(0x99) -> V(0) N(1) Z(0) C(1) A(0xF9)
+H(1) C(0) A(0x99) -> V(0) N(1) Z(0) C(0) A(0x9F)
+H(1) C(1) A(0x99) -> V(0) N(1) Z(0) C(1) A(0xFF)
+
+H(0) C(0) A(0x9A) -> V(0) N(0) Z(1) C(1) A(0x00)
+H(0) C(1) A(0x9A) -> V(0) N(0) Z(1) C(1) A(0x00)
+H(1) C(0) A(0x9A) -> V(0) N(0) Z(1) C(1) A(0x00)
+H(1) C(1) A(0x9A) -> V(0) N(0) Z(1) C(1) A(0x00)
+
+H(0) C(0) A(0x9B) -> V(0) N(0) Z(0) C(1) A(0x01)
+H(0) C(1) A(0x9B) -> V(0) N(0) Z(0) C(1) A(0x01)
+H(1) C(0) A(0x9B) -> V(0) N(0) Z(0) C(1) A(0x01)
+H(1) C(1) A(0x9B) -> V(0) N(0) Z(0) C(1) A(0x01)
+
+H(0) C(0) A(0x9C) -> V(0) N(0) Z(0) C(1) A(0x02)
+H(0) C(1) A(0x9C) -> V(0) N(0) Z(0) C(1) A(0x02)
+H(1) C(0) A(0x9C) -> V(0) N(0) Z(0) C(1) A(0x02)
+H(1) C(1) A(0x9C) -> V(0) N(0) Z(0) C(1) A(0x02)
+
+H(0) C(0) A(0x9D) -> V(0) N(0) Z(0) C(1) A(0x03)
+H(0) C(1) A(0x9D) -> V(0) N(0) Z(0) C(1) A(0x03)
+H(1) C(0) A(0x9D) -> V(0) N(0) Z(0) C(1) A(0x03)
+H(1) C(1) A(0x9D) -> V(0) N(0) Z(0) C(1) A(0x03)
+
+H(0) C(0) A(0x9E) -> V(0) N(0) Z(0) C(1) A(0x04)
+H(0) C(1) A(0x9E) -> V(0) N(0) Z(0) C(1) A(0x04)
+H(1) C(0) A(0x9E) -> V(0) N(0) Z(0) C(1) A(0x04)
+H(1) C(1) A(0x9E) -> V(0) N(0) Z(0) C(1) A(0x04)
+
+H(0) C(0) A(0x9F) -> V(0) N(0) Z(0) C(1) A(0x05)
+H(0) C(1) A(0x9F) -> V(0) N(0) Z(0) C(1) A(0x05)
+H(1) C(0) A(0x9F) -> V(0) N(0) Z(0) C(1) A(0x05)
+H(1) C(1) A(0x9F) -> V(0) N(0) Z(0) C(1) A(0x05)
+
+H(0) C(0) A(0xA0) -> V(0) N(0) Z(1) C(1) A(0x00)
+H(0) C(1) A(0xA0) -> V(0) N(0) Z(1) C(1) A(0x00)
+H(1) C(0) A(0xA0) -> V(0) N(0) Z(0) C(1) A(0x06)
+H(1) C(1) A(0xA0) -> V(0) N(0) Z(0) C(1) A(0x06)
+
+H(0) C(0) A(0xA1) -> V(0) N(0) Z(0) C(1) A(0x01)
+H(0) C(1) A(0xA1) -> V(0) N(0) Z(0) C(1) A(0x01)
+H(1) C(0) A(0xA1) -> V(0) N(0) Z(0) C(1) A(0x07)
+H(1) C(1) A(0xA1) -> V(0) N(0) Z(0) C(1) A(0x07)
+
+H(0) C(0) A(0xA2) -> V(0) N(0) Z(0) C(1) A(0x02)
+H(0) C(1) A(0xA2) -> V(0) N(0) Z(0) C(1) A(0x02)
+H(1) C(0) A(0xA2) -> V(0) N(0) Z(0) C(1) A(0x08)
+H(1) C(1) A(0xA2) -> V(0) N(0) Z(0) C(1) A(0x08)
+
+H(0) C(0) A(0xA3) -> V(0) N(0) Z(0) C(1) A(0x03)
+H(0) C(1) A(0xA3) -> V(0) N(0) Z(0) C(1) A(0x03)
+H(1) C(0) A(0xA3) -> V(0) N(0) Z(0) C(1) A(0x09)
+H(1) C(1) A(0xA3) -> V(0) N(0) Z(0) C(1) A(0x09)
+
+H(0) C(0) A(0xA4) -> V(0) N(0) Z(0) C(1) A(0x04)
+H(0) C(1) A(0xA4) -> V(0) N(0) Z(0) C(1) A(0x04)
+H(1) C(0) A(0xA4) -> V(0) N(0) Z(0) C(1) A(0x0A)
+H(1) C(1) A(0xA4) -> V(0) N(0) Z(0) C(1) A(0x0A)
+
+H(0) C(0) A(0xA5) -> V(0) N(0) Z(0) C(1) A(0x05)
+H(0) C(1) A(0xA5) -> V(0) N(0) Z(0) C(1) A(0x05)
+H(1) C(0) A(0xA5) -> V(0) N(0) Z(0) C(1) A(0x0B)
+H(1) C(1) A(0xA5) -> V(0) N(0) Z(0) C(1) A(0x0B)
+
+H(0) C(0) A(0xA6) -> V(0) N(0) Z(0) C(1) A(0x06)
+H(0) C(1) A(0xA6) -> V(0) N(0) Z(0) C(1) A(0x06)
+H(1) C(0) A(0xA6) -> V(0) N(0) Z(0) C(1) A(0x0C)
+H(1) C(1) A(0xA6) -> V(0) N(0) Z(0) C(1) A(0x0C)
+
+H(0) C(0) A(0xA7) -> V(0) N(0) Z(0) C(1) A(0x07)
+H(0) C(1) A(0xA7) -> V(0) N(0) Z(0) C(1) A(0x07)
+H(1) C(0) A(0xA7) -> V(0) N(0) Z(0) C(1) A(0x0D)
+H(1) C(1) A(0xA7) -> V(0) N(0) Z(0) C(1) A(0x0D)
+
+H(0) C(0) A(0xA8) -> V(0) N(0) Z(0) C(1) A(0x08)
+H(0) C(1) A(0xA8) -> V(0) N(0) Z(0) C(1) A(0x08)
+H(1) C(0) A(0xA8) -> V(0) N(0) Z(0) C(1) A(0x0E)
+H(1) C(1) A(0xA8) -> V(0) N(0) Z(0) C(1) A(0x0E)
+
+H(0) C(0) A(0xA9) -> V(0) N(0) Z(0) C(1) A(0x09)
+H(0) C(1) A(0xA9) -> V(0) N(0) Z(0) C(1) A(0x09)
+H(1) C(0) A(0xA9) -> V(0) N(0) Z(0) C(1) A(0x0F)
+H(1) C(1) A(0xA9) -> V(0) N(0) Z(0) C(1) A(0x0F)
+
+H(0) C(0) A(0xAA) -> V(0) N(0) Z(0) C(1) A(0x10)
+H(0) C(1) A(0xAA) -> V(0) N(0) Z(0) C(1) A(0x10)
+H(1) C(0) A(0xAA) -> V(0) N(0) Z(0) C(1) A(0x10)
+H(1) C(1) A(0xAA) -> V(0) N(0) Z(0) C(1) A(0x10)
+
+H(0) C(0) A(0xAB) -> V(0) N(0) Z(0) C(1) A(0x11)
+H(0) C(1) A(0xAB) -> V(0) N(0) Z(0) C(1) A(0x11)
+H(1) C(0) A(0xAB) -> V(0) N(0) Z(0) C(1) A(0x11)
+H(1) C(1) A(0xAB) -> V(0) N(0) Z(0) C(1) A(0x11)
+
+H(0) C(0) A(0xAC) -> V(0) N(0) Z(0) C(1) A(0x12)
+H(0) C(1) A(0xAC) -> V(0) N(0) Z(0) C(1) A(0x12)
+H(1) C(0) A(0xAC) -> V(0) N(0) Z(0) C(1) A(0x12)
+H(1) C(1) A(0xAC) -> V(0) N(0) Z(0) C(1) A(0x12)
+
+H(0) C(0) A(0xAD) -> V(0) N(0) Z(0) C(1) A(0x13)
+H(0) C(1) A(0xAD) -> V(0) N(0) Z(0) C(1) A(0x13)
+H(1) C(0) A(0xAD) -> V(0) N(0) Z(0) C(1) A(0x13)
+H(1) C(1) A(0xAD) -> V(0) N(0) Z(0) C(1) A(0x13)
+
+H(0) C(0) A(0xAE) -> V(0) N(0) Z(0) C(1) A(0x14)
+H(0) C(1) A(0xAE) -> V(0) N(0) Z(0) C(1) A(0x14)
+H(1) C(0) A(0xAE) -> V(0) N(0) Z(0) C(1) A(0x14)
+H(1) C(1) A(0xAE) -> V(0) N(0) Z(0) C(1) A(0x14)
+
+H(0) C(0) A(0xAF) -> V(0) N(0) Z(0) C(1) A(0x15)
+H(0) C(1) A(0xAF) -> V(0) N(0) Z(0) C(1) A(0x15)
+H(1) C(0) A(0xAF) -> V(0) N(0) Z(0) C(1) A(0x15)
+H(1) C(1) A(0xAF) -> V(0) N(0) Z(0) C(1) A(0x15)
+
+H(0) C(0) A(0xB0) -> V(0) N(0) Z(0) C(1) A(0x10)
+H(0) C(1) A(0xB0) -> V(0) N(0) Z(0) C(1) A(0x10)
+H(1) C(0) A(0xB0) -> V(0) N(0) Z(0) C(1) A(0x16)
+H(1) C(1) A(0xB0) -> V(0) N(0) Z(0) C(1) A(0x16)
+
+H(0) C(0) A(0xB1) -> V(0) N(0) Z(0) C(1) A(0x11)
+H(0) C(1) A(0xB1) -> V(0) N(0) Z(0) C(1) A(0x11)
+H(1) C(0) A(0xB1) -> V(0) N(0) Z(0) C(1) A(0x17)
+H(1) C(1) A(0xB1) -> V(0) N(0) Z(0) C(1) A(0x17)
+
+H(0) C(0) A(0xB2) -> V(0) N(0) Z(0) C(1) A(0x12)
+H(0) C(1) A(0xB2) -> V(0) N(0) Z(0) C(1) A(0x12)
+H(1) C(0) A(0xB2) -> V(0) N(0) Z(0) C(1) A(0x18)
+H(1) C(1) A(0xB2) -> V(0) N(0) Z(0) C(1) A(0x18)
+
+H(0) C(0) A(0xB3) -> V(0) N(0) Z(0) C(1) A(0x13)
+H(0) C(1) A(0xB3) -> V(0) N(0) Z(0) C(1) A(0x13)
+H(1) C(0) A(0xB3) -> V(0) N(0) Z(0) C(1) A(0x19)
+H(1) C(1) A(0xB3) -> V(0) N(0) Z(0) C(1) A(0x19)
+
+H(0) C(0) A(0xB4) -> V(0) N(0) Z(0) C(1) A(0x14)
+H(0) C(1) A(0xB4) -> V(0) N(0) Z(0) C(1) A(0x14)
+H(1) C(0) A(0xB4) -> V(0) N(0) Z(0) C(1) A(0x1A)
+H(1) C(1) A(0xB4) -> V(0) N(0) Z(0) C(1) A(0x1A)
+
+H(0) C(0) A(0xB5) -> V(0) N(0) Z(0) C(1) A(0x15)
+H(0) C(1) A(0xB5) -> V(0) N(0) Z(0) C(1) A(0x15)
+H(1) C(0) A(0xB5) -> V(0) N(0) Z(0) C(1) A(0x1B)
+H(1) C(1) A(0xB5) -> V(0) N(0) Z(0) C(1) A(0x1B)
+
+H(0) C(0) A(0xB6) -> V(0) N(0) Z(0) C(1) A(0x16)
+H(0) C(1) A(0xB6) -> V(0) N(0) Z(0) C(1) A(0x16)
+H(1) C(0) A(0xB6) -> V(0) N(0) Z(0) C(1) A(0x1C)
+H(1) C(1) A(0xB6) -> V(0) N(0) Z(0) C(1) A(0x1C)
+
+H(0) C(0) A(0xB7) -> V(0) N(0) Z(0) C(1) A(0x17)
+H(0) C(1) A(0xB7) -> V(0) N(0) Z(0) C(1) A(0x17)
+H(1) C(0) A(0xB7) -> V(0) N(0) Z(0) C(1) A(0x1D)
+H(1) C(1) A(0xB7) -> V(0) N(0) Z(0) C(1) A(0x1D)
+
+H(0) C(0) A(0xB8) -> V(0) N(0) Z(0) C(1) A(0x18)
+H(0) C(1) A(0xB8) -> V(0) N(0) Z(0) C(1) A(0x18)
+H(1) C(0) A(0xB8) -> V(0) N(0) Z(0) C(1) A(0x1E)
+H(1) C(1) A(0xB8) -> V(0) N(0) Z(0) C(1) A(0x1E)
+
+H(0) C(0) A(0xB9) -> V(0) N(0) Z(0) C(1) A(0x19)
+H(0) C(1) A(0xB9) -> V(0) N(0) Z(0) C(1) A(0x19)
+H(1) C(0) A(0xB9) -> V(0) N(0) Z(0) C(1) A(0x1F)
+H(1) C(1) A(0xB9) -> V(0) N(0) Z(0) C(1) A(0x1F)
+
+H(0) C(0) A(0xBA) -> V(0) N(0) Z(0) C(1) A(0x20)
+H(0) C(1) A(0xBA) -> V(0) N(0) Z(0) C(1) A(0x20)
+H(1) C(0) A(0xBA) -> V(0) N(0) Z(0) C(1) A(0x20)
+H(1) C(1) A(0xBA) -> V(0) N(0) Z(0) C(1) A(0x20)
+
+H(0) C(0) A(0xBB) -> V(0) N(0) Z(0) C(1) A(0x21)
+H(0) C(1) A(0xBB) -> V(0) N(0) Z(0) C(1) A(0x21)
+H(1) C(0) A(0xBB) -> V(0) N(0) Z(0) C(1) A(0x21)
+H(1) C(1) A(0xBB) -> V(0) N(0) Z(0) C(1) A(0x21)
+
+H(0) C(0) A(0xBC) -> V(0) N(0) Z(0) C(1) A(0x22)
+H(0) C(1) A(0xBC) -> V(0) N(0) Z(0) C(1) A(0x22)
+H(1) C(0) A(0xBC) -> V(0) N(0) Z(0) C(1) A(0x22)
+H(1) C(1) A(0xBC) -> V(0) N(0) Z(0) C(1) A(0x22)
+
+H(0) C(0) A(0xBD) -> V(0) N(0) Z(0) C(1) A(0x23)
+H(0) C(1) A(0xBD) -> V(0) N(0) Z(0) C(1) A(0x23)
+H(1) C(0) A(0xBD) -> V(0) N(0) Z(0) C(1) A(0x23)
+H(1) C(1) A(0xBD) -> V(0) N(0) Z(0) C(1) A(0x23)
+
+H(0) C(0) A(0xBE) -> V(0) N(0) Z(0) C(1) A(0x24)
+H(0) C(1) A(0xBE) -> V(0) N(0) Z(0) C(1) A(0x24)
+H(1) C(0) A(0xBE) -> V(0) N(0) Z(0) C(1) A(0x24)
+H(1) C(1) A(0xBE) -> V(0) N(0) Z(0) C(1) A(0x24)
+
+H(0) C(0) A(0xBF) -> V(0) N(0) Z(0) C(1) A(0x25)
+H(0) C(1) A(0xBF) -> V(0) N(0) Z(0) C(1) A(0x25)
+H(1) C(0) A(0xBF) -> V(0) N(0) Z(0) C(1) A(0x25)
+H(1) C(1) A(0xBF) -> V(0) N(0) Z(0) C(1) A(0x25)
+
+H(0) C(0) A(0xC0) -> V(0) N(0) Z(0) C(1) A(0x20)
+H(0) C(1) A(0xC0) -> V(0) N(0) Z(0) C(1) A(0x20)
+H(1) C(0) A(0xC0) -> V(0) N(0) Z(0) C(1) A(0x26)
+H(1) C(1) A(0xC0) -> V(0) N(0) Z(0) C(1) A(0x26)
+
+H(0) C(0) A(0xC1) -> V(0) N(0) Z(0) C(1) A(0x21)
+H(0) C(1) A(0xC1) -> V(0) N(0) Z(0) C(1) A(0x21)
+H(1) C(0) A(0xC1) -> V(0) N(0) Z(0) C(1) A(0x27)
+H(1) C(1) A(0xC1) -> V(0) N(0) Z(0) C(1) A(0x27)
+
+H(0) C(0) A(0xC2) -> V(0) N(0) Z(0) C(1) A(0x22)
+H(0) C(1) A(0xC2) -> V(0) N(0) Z(0) C(1) A(0x22)
+H(1) C(0) A(0xC2) -> V(0) N(0) Z(0) C(1) A(0x28)
+H(1) C(1) A(0xC2) -> V(0) N(0) Z(0) C(1) A(0x28)
+
+H(0) C(0) A(0xC3) -> V(0) N(0) Z(0) C(1) A(0x23)
+H(0) C(1) A(0xC3) -> V(0) N(0) Z(0) C(1) A(0x23)
+H(1) C(0) A(0xC3) -> V(0) N(0) Z(0) C(1) A(0x29)
+H(1) C(1) A(0xC3) -> V(0) N(0) Z(0) C(1) A(0x29)
+
+H(0) C(0) A(0xC4) -> V(0) N(0) Z(0) C(1) A(0x24)
+H(0) C(1) A(0xC4) -> V(0) N(0) Z(0) C(1) A(0x24)
+H(1) C(0) A(0xC4) -> V(0) N(0) Z(0) C(1) A(0x2A)
+H(1) C(1) A(0xC4) -> V(0) N(0) Z(0) C(1) A(0x2A)
+
+H(0) C(0) A(0xC5) -> V(0) N(0) Z(0) C(1) A(0x25)
+H(0) C(1) A(0xC5) -> V(0) N(0) Z(0) C(1) A(0x25)
+H(1) C(0) A(0xC5) -> V(0) N(0) Z(0) C(1) A(0x2B)
+H(1) C(1) A(0xC5) -> V(0) N(0) Z(0) C(1) A(0x2B)
+
+H(0) C(0) A(0xC6) -> V(0) N(0) Z(0) C(1) A(0x26)
+H(0) C(1) A(0xC6) -> V(0) N(0) Z(0) C(1) A(0x26)
+H(1) C(0) A(0xC6) -> V(0) N(0) Z(0) C(1) A(0x2C)
+H(1) C(1) A(0xC6) -> V(0) N(0) Z(0) C(1) A(0x2C)
+
+H(0) C(0) A(0xC7) -> V(0) N(0) Z(0) C(1) A(0x27)
+H(0) C(1) A(0xC7) -> V(0) N(0) Z(0) C(1) A(0x27)
+H(1) C(0) A(0xC7) -> V(0) N(0) Z(0) C(1) A(0x2D)
+H(1) C(1) A(0xC7) -> V(0) N(0) Z(0) C(1) A(0x2D)
+
+H(0) C(0) A(0xC8) -> V(0) N(0) Z(0) C(1) A(0x28)
+H(0) C(1) A(0xC8) -> V(0) N(0) Z(0) C(1) A(0x28)
+H(1) C(0) A(0xC8) -> V(0) N(0) Z(0) C(1) A(0x2E)
+H(1) C(1) A(0xC8) -> V(0) N(0) Z(0) C(1) A(0x2E)
+
+H(0) C(0) A(0xC9) -> V(0) N(0) Z(0) C(1) A(0x29)
+H(0) C(1) A(0xC9) -> V(0) N(0) Z(0) C(1) A(0x29)
+H(1) C(0) A(0xC9) -> V(0) N(0) Z(0) C(1) A(0x2F)
+H(1) C(1) A(0xC9) -> V(0) N(0) Z(0) C(1) A(0x2F)
+
+H(0) C(0) A(0xCA) -> V(0) N(0) Z(0) C(1) A(0x30)
+H(0) C(1) A(0xCA) -> V(0) N(0) Z(0) C(1) A(0x30)
+H(1) C(0) A(0xCA) -> V(0) N(0) Z(0) C(1) A(0x30)
+H(1) C(1) A(0xCA) -> V(0) N(0) Z(0) C(1) A(0x30)
+
+H(0) C(0) A(0xCB) -> V(0) N(0) Z(0) C(1) A(0x31)
+H(0) C(1) A(0xCB) -> V(0) N(0) Z(0) C(1) A(0x31)
+H(1) C(0) A(0xCB) -> V(0) N(0) Z(0) C(1) A(0x31)
+H(1) C(1) A(0xCB) -> V(0) N(0) Z(0) C(1) A(0x31)
+
+H(0) C(0) A(0xCC) -> V(0) N(0) Z(0) C(1) A(0x32)
+H(0) C(1) A(0xCC) -> V(0) N(0) Z(0) C(1) A(0x32)
+H(1) C(0) A(0xCC) -> V(0) N(0) Z(0) C(1) A(0x32)
+H(1) C(1) A(0xCC) -> V(0) N(0) Z(0) C(1) A(0x32)
+
+H(0) C(0) A(0xCD) -> V(0) N(0) Z(0) C(1) A(0x33)
+H(0) C(1) A(0xCD) -> V(0) N(0) Z(0) C(1) A(0x33)
+H(1) C(0) A(0xCD) -> V(0) N(0) Z(0) C(1) A(0x33)
+H(1) C(1) A(0xCD) -> V(0) N(0) Z(0) C(1) A(0x33)
+
+H(0) C(0) A(0xCE) -> V(0) N(0) Z(0) C(1) A(0x34)
+H(0) C(1) A(0xCE) -> V(0) N(0) Z(0) C(1) A(0x34)
+H(1) C(0) A(0xCE) -> V(0) N(0) Z(0) C(1) A(0x34)
+H(1) C(1) A(0xCE) -> V(0) N(0) Z(0) C(1) A(0x34)
+
+H(0) C(0) A(0xCF) -> V(0) N(0) Z(0) C(1) A(0x35)
+H(0) C(1) A(0xCF) -> V(0) N(0) Z(0) C(1) A(0x35)
+H(1) C(0) A(0xCF) -> V(0) N(0) Z(0) C(1) A(0x35)
+H(1) C(1) A(0xCF) -> V(0) N(0) Z(0) C(1) A(0x35)
+
+H(0) C(0) A(0xD0) -> V(0) N(0) Z(0) C(1) A(0x30)
+H(0) C(1) A(0xD0) -> V(0) N(0) Z(0) C(1) A(0x30)
+H(1) C(0) A(0xD0) -> V(0) N(0) Z(0) C(1) A(0x36)
+H(1) C(1) A(0xD0) -> V(0) N(0) Z(0) C(1) A(0x36)
+
+H(0) C(0) A(0xD1) -> V(0) N(0) Z(0) C(1) A(0x31)
+H(0) C(1) A(0xD1) -> V(0) N(0) Z(0) C(1) A(0x31)
+H(1) C(0) A(0xD1) -> V(0) N(0) Z(0) C(1) A(0x37)
+H(1) C(1) A(0xD1) -> V(0) N(0) Z(0) C(1) A(0x37)
+
+H(0) C(0) A(0xD2) -> V(0) N(0) Z(0) C(1) A(0x32)
+H(0) C(1) A(0xD2) -> V(0) N(0) Z(0) C(1) A(0x32)
+H(1) C(0) A(0xD2) -> V(0) N(0) Z(0) C(1) A(0x38)
+H(1) C(1) A(0xD2) -> V(0) N(0) Z(0) C(1) A(0x38)
+
+H(0) C(0) A(0xD3) -> V(0) N(0) Z(0) C(1) A(0x33)
+H(0) C(1) A(0xD3) -> V(0) N(0) Z(0) C(1) A(0x33)
+H(1) C(0) A(0xD3) -> V(0) N(0) Z(0) C(1) A(0x39)
+H(1) C(1) A(0xD3) -> V(0) N(0) Z(0) C(1) A(0x39)
+
+H(0) C(0) A(0xD4) -> V(0) N(0) Z(0) C(1) A(0x34)
+H(0) C(1) A(0xD4) -> V(0) N(0) Z(0) C(1) A(0x34)
+H(1) C(0) A(0xD4) -> V(0) N(0) Z(0) C(1) A(0x3A)
+H(1) C(1) A(0xD4) -> V(0) N(0) Z(0) C(1) A(0x3A)
+
+H(0) C(0) A(0xD5) -> V(0) N(0) Z(0) C(1) A(0x35)
+H(0) C(1) A(0xD5) -> V(0) N(0) Z(0) C(1) A(0x35)
+H(1) C(0) A(0xD5) -> V(0) N(0) Z(0) C(1) A(0x3B)
+H(1) C(1) A(0xD5) -> V(0) N(0) Z(0) C(1) A(0x3B)
+
+H(0) C(0) A(0xD6) -> V(0) N(0) Z(0) C(1) A(0x36)
+H(0) C(1) A(0xD6) -> V(0) N(0) Z(0) C(1) A(0x36)
+H(1) C(0) A(0xD6) -> V(0) N(0) Z(0) C(1) A(0x3C)
+H(1) C(1) A(0xD6) -> V(0) N(0) Z(0) C(1) A(0x3C)
+
+H(0) C(0) A(0xD7) -> V(0) N(0) Z(0) C(1) A(0x37)
+H(0) C(1) A(0xD7) -> V(0) N(0) Z(0) C(1) A(0x37)
+H(1) C(0) A(0xD7) -> V(0) N(0) Z(0) C(1) A(0x3D)
+H(1) C(1) A(0xD7) -> V(0) N(0) Z(0) C(1) A(0x3D)
+
+H(0) C(0) A(0xD8) -> V(0) N(0) Z(0) C(1) A(0x38)
+H(0) C(1) A(0xD8) -> V(0) N(0) Z(0) C(1) A(0x38)
+H(1) C(0) A(0xD8) -> V(0) N(0) Z(0) C(1) A(0x3E)
+H(1) C(1) A(0xD8) -> V(0) N(0) Z(0) C(1) A(0x3E)
+
+H(0) C(0) A(0xD9) -> V(0) N(0) Z(0) C(1) A(0x39)
+H(0) C(1) A(0xD9) -> V(0) N(0) Z(0) C(1) A(0x39)
+H(1) C(0) A(0xD9) -> V(0) N(0) Z(0) C(1) A(0x3F)
+H(1) C(1) A(0xD9) -> V(0) N(0) Z(0) C(1) A(0x3F)
+
+H(0) C(0) A(0xDA) -> V(0) N(0) Z(0) C(1) A(0x40)
+H(0) C(1) A(0xDA) -> V(0) N(0) Z(0) C(1) A(0x40)
+H(1) C(0) A(0xDA) -> V(0) N(0) Z(0) C(1) A(0x40)
+H(1) C(1) A(0xDA) -> V(0) N(0) Z(0) C(1) A(0x40)
+
+H(0) C(0) A(0xDB) -> V(0) N(0) Z(0) C(1) A(0x41)
+H(0) C(1) A(0xDB) -> V(0) N(0) Z(0) C(1) A(0x41)
+H(1) C(0) A(0xDB) -> V(0) N(0) Z(0) C(1) A(0x41)
+H(1) C(1) A(0xDB) -> V(0) N(0) Z(0) C(1) A(0x41)
+
+H(0) C(0) A(0xDC) -> V(0) N(0) Z(0) C(1) A(0x42)
+H(0) C(1) A(0xDC) -> V(0) N(0) Z(0) C(1) A(0x42)
+H(1) C(0) A(0xDC) -> V(0) N(0) Z(0) C(1) A(0x42)
+H(1) C(1) A(0xDC) -> V(0) N(0) Z(0) C(1) A(0x42)
+
+H(0) C(0) A(0xDD) -> V(0) N(0) Z(0) C(1) A(0x43)
+H(0) C(1) A(0xDD) -> V(0) N(0) Z(0) C(1) A(0x43)
+H(1) C(0) A(0xDD) -> V(0) N(0) Z(0) C(1) A(0x43)
+H(1) C(1) A(0xDD) -> V(0) N(0) Z(0) C(1) A(0x43)
+
+H(0) C(0) A(0xDE) -> V(0) N(0) Z(0) C(1) A(0x44)
+H(0) C(1) A(0xDE) -> V(0) N(0) Z(0) C(1) A(0x44)
+H(1) C(0) A(0xDE) -> V(0) N(0) Z(0) C(1) A(0x44)
+H(1) C(1) A(0xDE) -> V(0) N(0) Z(0) C(1) A(0x44)
+
+H(0) C(0) A(0xDF) -> V(0) N(0) Z(0) C(1) A(0x45)
+H(0) C(1) A(0xDF) -> V(0) N(0) Z(0) C(1) A(0x45)
+H(1) C(0) A(0xDF) -> V(0) N(0) Z(0) C(1) A(0x45)
+H(1) C(1) A(0xDF) -> V(0) N(0) Z(0) C(1) A(0x45)
+
+H(0) C(0) A(0xE0) -> V(0) N(0) Z(0) C(1) A(0x40)
+H(0) C(1) A(0xE0) -> V(0) N(0) Z(0) C(1) A(0x40)
+H(1) C(0) A(0xE0) -> V(0) N(0) Z(0) C(1) A(0x46)
+H(1) C(1) A(0xE0) -> V(0) N(0) Z(0) C(1) A(0x46)
+
+H(0) C(0) A(0xE1) -> V(0) N(0) Z(0) C(1) A(0x41)
+H(0) C(1) A(0xE1) -> V(0) N(0) Z(0) C(1) A(0x41)
+H(1) C(0) A(0xE1) -> V(0) N(0) Z(0) C(1) A(0x47)
+H(1) C(1) A(0xE1) -> V(0) N(0) Z(0) C(1) A(0x47)
+
+H(0) C(0) A(0xE2) -> V(0) N(0) Z(0) C(1) A(0x42)
+H(0) C(1) A(0xE2) -> V(0) N(0) Z(0) C(1) A(0x42)
+H(1) C(0) A(0xE2) -> V(0) N(0) Z(0) C(1) A(0x48)
+H(1) C(1) A(0xE2) -> V(0) N(0) Z(0) C(1) A(0x48)
+
+H(0) C(0) A(0xE3) -> V(0) N(0) Z(0) C(1) A(0x43)
+H(0) C(1) A(0xE3) -> V(0) N(0) Z(0) C(1) A(0x43)
+H(1) C(0) A(0xE3) -> V(0) N(0) Z(0) C(1) A(0x49)
+H(1) C(1) A(0xE3) -> V(0) N(0) Z(0) C(1) A(0x49)
+
+H(0) C(0) A(0xE4) -> V(0) N(0) Z(0) C(1) A(0x44)
+H(0) C(1) A(0xE4) -> V(0) N(0) Z(0) C(1) A(0x44)
+H(1) C(0) A(0xE4) -> V(0) N(0) Z(0) C(1) A(0x4A)
+H(1) C(1) A(0xE4) -> V(0) N(0) Z(0) C(1) A(0x4A)
+
+H(0) C(0) A(0xE5) -> V(0) N(0) Z(0) C(1) A(0x45)
+H(0) C(1) A(0xE5) -> V(0) N(0) Z(0) C(1) A(0x45)
+H(1) C(0) A(0xE5) -> V(0) N(0) Z(0) C(1) A(0x4B)
+H(1) C(1) A(0xE5) -> V(0) N(0) Z(0) C(1) A(0x4B)
+
+H(0) C(0) A(0xE6) -> V(0) N(0) Z(0) C(1) A(0x46)
+H(0) C(1) A(0xE6) -> V(0) N(0) Z(0) C(1) A(0x46)
+H(1) C(0) A(0xE6) -> V(0) N(0) Z(0) C(1) A(0x4C)
+H(1) C(1) A(0xE6) -> V(0) N(0) Z(0) C(1) A(0x4C)
+
+H(0) C(0) A(0xE7) -> V(0) N(0) Z(0) C(1) A(0x47)
+H(0) C(1) A(0xE7) -> V(0) N(0) Z(0) C(1) A(0x47)
+H(1) C(0) A(0xE7) -> V(0) N(0) Z(0) C(1) A(0x4D)
+H(1) C(1) A(0xE7) -> V(0) N(0) Z(0) C(1) A(0x4D)
+
+H(0) C(0) A(0xE8) -> V(0) N(0) Z(0) C(1) A(0x48)
+H(0) C(1) A(0xE8) -> V(0) N(0) Z(0) C(1) A(0x48)
+H(1) C(0) A(0xE8) -> V(0) N(0) Z(0) C(1) A(0x4E)
+H(1) C(1) A(0xE8) -> V(0) N(0) Z(0) C(1) A(0x4E)
+
+H(0) C(0) A(0xE9) -> V(0) N(0) Z(0) C(1) A(0x49)
+H(0) C(1) A(0xE9) -> V(0) N(0) Z(0) C(1) A(0x49)
+H(1) C(0) A(0xE9) -> V(0) N(0) Z(0) C(1) A(0x4F)
+H(1) C(1) A(0xE9) -> V(0) N(0) Z(0) C(1) A(0x4F)
+
+H(0) C(0) A(0xEA) -> V(0) N(0) Z(0) C(1) A(0x50)
+H(0) C(1) A(0xEA) -> V(0) N(0) Z(0) C(1) A(0x50)
+H(1) C(0) A(0xEA) -> V(0) N(0) Z(0) C(1) A(0x50)
+H(1) C(1) A(0xEA) -> V(0) N(0) Z(0) C(1) A(0x50)
+
+H(0) C(0) A(0xEB) -> V(0) N(0) Z(0) C(1) A(0x51)
+H(0) C(1) A(0xEB) -> V(0) N(0) Z(0) C(1) A(0x51)
+H(1) C(0) A(0xEB) -> V(0) N(0) Z(0) C(1) A(0x51)
+H(1) C(1) A(0xEB) -> V(0) N(0) Z(0) C(1) A(0x51)
+
+H(0) C(0) A(0xEC) -> V(0) N(0) Z(0) C(1) A(0x52)
+H(0) C(1) A(0xEC) -> V(0) N(0) Z(0) C(1) A(0x52)
+H(1) C(0) A(0xEC) -> V(0) N(0) Z(0) C(1) A(0x52)
+H(1) C(1) A(0xEC) -> V(0) N(0) Z(0) C(1) A(0x52)
+
+H(0) C(0) A(0xED) -> V(0) N(0) Z(0) C(1) A(0x53)
+H(0) C(1) A(0xED) -> V(0) N(0) Z(0) C(1) A(0x53)
+H(1) C(0) A(0xED) -> V(0) N(0) Z(0) C(1) A(0x53)
+H(1) C(1) A(0xED) -> V(0) N(0) Z(0) C(1) A(0x53)
+
+H(0) C(0) A(0xEE) -> V(0) N(0) Z(0) C(1) A(0x54)
+H(0) C(1) A(0xEE) -> V(0) N(0) Z(0) C(1) A(0x54)
+H(1) C(0) A(0xEE) -> V(0) N(0) Z(0) C(1) A(0x54)
+H(1) C(1) A(0xEE) -> V(0) N(0) Z(0) C(1) A(0x54)
+
+H(0) C(0) A(0xEF) -> V(0) N(0) Z(0) C(1) A(0x55)
+H(0) C(1) A(0xEF) -> V(0) N(0) Z(0) C(1) A(0x55)
+H(1) C(0) A(0xEF) -> V(0) N(0) Z(0) C(1) A(0x55)
+H(1) C(1) A(0xEF) -> V(0) N(0) Z(0) C(1) A(0x55)
+
+H(0) C(0) A(0xF0) -> V(0) N(0) Z(0) C(1) A(0x50)
+H(0) C(1) A(0xF0) -> V(0) N(0) Z(0) C(1) A(0x50)
+H(1) C(0) A(0xF0) -> V(0) N(0) Z(0) C(1) A(0x56)
+H(1) C(1) A(0xF0) -> V(0) N(0) Z(0) C(1) A(0x56)
+
+H(0) C(0) A(0xF1) -> V(0) N(0) Z(0) C(1) A(0x51)
+H(0) C(1) A(0xF1) -> V(0) N(0) Z(0) C(1) A(0x51)
+H(1) C(0) A(0xF1) -> V(0) N(0) Z(0) C(1) A(0x57)
+H(1) C(1) A(0xF1) -> V(0) N(0) Z(0) C(1) A(0x57)
+
+H(0) C(0) A(0xF2) -> V(0) N(0) Z(0) C(1) A(0x52)
+H(0) C(1) A(0xF2) -> V(0) N(0) Z(0) C(1) A(0x52)
+H(1) C(0) A(0xF2) -> V(0) N(0) Z(0) C(1) A(0x58)
+H(1) C(1) A(0xF2) -> V(0) N(0) Z(0) C(1) A(0x58)
+
+H(0) C(0) A(0xF3) -> V(0) N(0) Z(0) C(1) A(0x53)
+H(0) C(1) A(0xF3) -> V(0) N(0) Z(0) C(1) A(0x53)
+H(1) C(0) A(0xF3) -> V(0) N(0) Z(0) C(1) A(0x59)
+H(1) C(1) A(0xF3) -> V(0) N(0) Z(0) C(1) A(0x59)
+
+H(0) C(0) A(0xF4) -> V(0) N(0) Z(0) C(1) A(0x54)
+H(0) C(1) A(0xF4) -> V(0) N(0) Z(0) C(1) A(0x54)
+H(1) C(0) A(0xF4) -> V(0) N(0) Z(0) C(1) A(0x5A)
+H(1) C(1) A(0xF4) -> V(0) N(0) Z(0) C(1) A(0x5A)
+
+H(0) C(0) A(0xF5) -> V(0) N(0) Z(0) C(1) A(0x55)
+H(0) C(1) A(0xF5) -> V(0) N(0) Z(0) C(1) A(0x55)
+H(1) C(0) A(0xF5) -> V(0) N(0) Z(0) C(1) A(0x5B)
+H(1) C(1) A(0xF5) -> V(0) N(0) Z(0) C(1) A(0x5B)
+
+H(0) C(0) A(0xF6) -> V(0) N(0) Z(0) C(1) A(0x56)
+H(0) C(1) A(0xF6) -> V(0) N(0) Z(0) C(1) A(0x56)
+H(1) C(0) A(0xF6) -> V(0) N(0) Z(0) C(1) A(0x5C)
+H(1) C(1) A(0xF6) -> V(0) N(0) Z(0) C(1) A(0x5C)
+
+H(0) C(0) A(0xF7) -> V(0) N(0) Z(0) C(1) A(0x57)
+H(0) C(1) A(0xF7) -> V(0) N(0) Z(0) C(1) A(0x57)
+H(1) C(0) A(0xF7) -> V(0) N(0) Z(0) C(1) A(0x5D)
+H(1) C(1) A(0xF7) -> V(0) N(0) Z(0) C(1) A(0x5D)
+
+H(0) C(0) A(0xF8) -> V(0) N(0) Z(0) C(1) A(0x58)
+H(0) C(1) A(0xF8) -> V(0) N(0) Z(0) C(1) A(0x58)
+H(1) C(0) A(0xF8) -> V(0) N(0) Z(0) C(1) A(0x5E)
+H(1) C(1) A(0xF8) -> V(0) N(0) Z(0) C(1) A(0x5E)
+
+H(0) C(0) A(0xF9) -> V(0) N(0) Z(0) C(1) A(0x59)
+H(0) C(1) A(0xF9) -> V(0) N(0) Z(0) C(1) A(0x59)
+H(1) C(0) A(0xF9) -> V(0) N(0) Z(0) C(1) A(0x5F)
+H(1) C(1) A(0xF9) -> V(0) N(0) Z(0) C(1) A(0x5F)
+
+H(0) C(0) A(0xFA) -> V(0) N(0) Z(0) C(1) A(0x60)
+H(0) C(1) A(0xFA) -> V(0) N(0) Z(0) C(1) A(0x60)
+H(1) C(0) A(0xFA) -> V(0) N(0) Z(0) C(1) A(0x60)
+H(1) C(1) A(0xFA) -> V(0) N(0) Z(0) C(1) A(0x60)
+
+H(0) C(0) A(0xFB) -> V(0) N(0) Z(0) C(1) A(0x61)
+H(0) C(1) A(0xFB) -> V(0) N(0) Z(0) C(1) A(0x61)
+H(1) C(0) A(0xFB) -> V(0) N(0) Z(0) C(1) A(0x61)
+H(1) C(1) A(0xFB) -> V(0) N(0) Z(0) C(1) A(0x61)
+
+H(0) C(0) A(0xFC) -> V(0) N(0) Z(0) C(1) A(0x62)
+H(0) C(1) A(0xFC) -> V(0) N(0) Z(0) C(1) A(0x62)
+H(1) C(0) A(0xFC) -> V(0) N(0) Z(0) C(1) A(0x62)
+H(1) C(1) A(0xFC) -> V(0) N(0) Z(0) C(1) A(0x62)
+
+H(0) C(0) A(0xFD) -> V(0) N(0) Z(0) C(1) A(0x63)
+H(0) C(1) A(0xFD) -> V(0) N(0) Z(0) C(1) A(0x63)
+H(1) C(0) A(0xFD) -> V(0) N(0) Z(0) C(1) A(0x63)
+H(1) C(1) A(0xFD) -> V(0) N(0) Z(0) C(1) A(0x63)
+
+H(0) C(0) A(0xFE) -> V(0) N(0) Z(0) C(1) A(0x64)
+H(0) C(1) A(0xFE) -> V(0) N(0) Z(0) C(1) A(0x64)
+H(1) C(0) A(0xFE) -> V(0) N(0) Z(0) C(1) A(0x64)
+H(1) C(1) A(0xFE) -> V(0) N(0) Z(0) C(1) A(0x64)
+
+H(0) C(0) A(0xFF) -> V(0) N(0) Z(0) C(1) A(0x65)
+H(0) C(1) A(0xFF) -> V(0) N(0) Z(0) C(1) A(0x65)
+H(1) C(0) A(0xFF) -> V(0) N(0) Z(0) C(1) A(0x65)
+H(1) C(1) A(0xFF) -> V(0) N(0) Z(0) C(1) A(0x65)
diff --git a/helm/software/matita/contribs/assembly/freescale/Doc/numeri_perfetti.txt b/helm/software/matita/contribs/assembly/freescale/Doc/numeri_perfetti.txt
new file mode 100755
index 000000000..36b77f07c
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/freescale/Doc/numeri_perfetti.txt
@@ -0,0 +1,302 @@
+
+NUMERI AUREI: Somma divisori(x)=x
+ Fino a 0xFFFF sono 6/28/496/8128
+
+static unsigned int result[16]={ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
+                            -> { 6, 28, 496, 8128 ... }
+
+void main(void)
+{
+unsigned int res_pos=0,tested_num=0,divisor=0;
+unsigned long int acc=0;
+
+for(tested_num=1;tested_num<2;tested_num++)
+ {
+ for(acc=0,divisor=1;divisor<tested_num;divisor++)
+  {
+  if(!(tested_num%divisor))
+   { acc+=divisor; }
+  }
+ 
+ if(acc==tested_num)
+  { result[res_pos++]=tested_num; }
+ }
+}
+
+*************************************
+
+A: 0x00 HX: 0x1A00 PC: 0x18BE SP: 0x016F Z:1 (I:1)
+A: 0x00 HX: num    PC: 0x1950 SP: 0x016F Z:1 (I:1)
+
+T(n) = 80+65*sum[i=1,n]{sum[k=1,i]{k}}
+cioe'
+T(n) = 80+(65*n*(n+1)*(n+2))/6
+
+   n  clocki clockf        clocktot      T(n)
+1000: 543 -> 156.302.031 | 156.301.488 | 10.865.855.080
+ 900: 543 -> 121.788.732 | 121.788.189 |  7.923.844.580
+ 800: 543 ->  91.818.647 |  91.818.104 |  5.567.484.080
+ 700: 543 ->  66.162.370 |  66.161.827 |  3.731.773.580
+ 600: 543 ->  44.814.748 |  44.814.205 |  2.351.713.080
+ 500: 543 ->  27.866.608 |  27.866.065 |  1.362.302.580
+*497: 543 ->  27.430.121 |  27.429.578 |  1.337.976.265
+ 496: 543 ->  27.284.097 |  27.283.554 |  1.329.932.320
+ 400: 543 ->  15.384.865 |  15.384.322 |    698.542.080
+ 300: 543 ->   7.308.541 |   7.307.998 |    295.431.580
+ 200: 543 ->   3.178.553 |   3.178.010 |     87.971.080
+ 100: 543 ->     826.875 |     826.332 |     11.160.580
+  50: 543 ->     218.618 |     218.075 |      1.436.580 
+ *29: 543 ->      77.875 |      77.332 |        292.255
+  28: 543 ->      72.452 |      71.909 |        263.980
+  20: 543 ->      38.104 |      37.561 |        100.180
+  10: 543 ->      10.307 |       9.764 |         14.380
+  *7: 543 ->       5.411 |       4.868 |          5.540
+   6: 543 ->       3.778 |       3.235 |          3.720
+   5: 543 ->       2.849 |       2.306 |          2.355
+   4: 543 ->       1.813 |       1.270 |          1.380
+   3: 543 ->       1.182 |         639 |            730
+   2: 543 ->         700 |         157 |            340
+   1: 543 ->         623 |          80 |            145
+
+quindi tempo di esecuzione e T(n), cioe' o(n^3)
+
+*********************************************
+
+static unsigned int result[16]={ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
+word result[16] = 0x0100
+
+void main(void)
+{
+unsigned int res_pos=0,tested_num=0,divisor=0;
+unsigned long int acc=0;
+
+18BE A7 F6    AIS #-10 <----------- INGRESSO MAIN
+18C0 95       TSX
+18C1 6F 09    CLR 9,X
+18C3 6F 08    CLR 8,X
+18C5 6F 01    CLR 1,X
+18C7 7F       CLR ,X
+18C8 6F 03    CLR 3,X
+18CA 6F 02    CLR 2,X
+18CC CD 19 51 JSR 0x1951 ; 0x1951
+
+for(tested_num=1;tested_num<2;tested_num++)
+ {
+
+18CF 9E FF 01 STHX 1,SP
+18D2 20 72    BRA *+116 ; 0x1946
+18D4 AD 7B    BSR *+125 ; 0x1951
+18D6 9E FF 03 STHX 3,SP
+
+ for(acc=0,divisor=1;divisor<tested_num;divisor++)
+  {
+  if(!(tested_num%divisor))
+   { acc+=divisor; }
+  }
+
+18D9 20 3B    BRA *+61 ; 0x1916
+18DB 9E FE 01 LDHX 1,SP
+18DE 89       PSHX
+18DF 8B       PSHH
+18E0 9E FE 05 LDHX 5,SP
+18E3 CD 1A 1A JSR 0x1A1A ; 0x1A1A
+18E6 A7 02    AIS #2
+18E8 65 00 00 CPHX #0x0000
+18EB 26 1F    BNE *+33 ; 0x190C
+18ED 95       TSX
+18EE E6 03    LDA 3,X
+18F0 EE 02    LDX 2,X
+18F2 87       PSHA
+18F3 89       PSHX
+18F4 4F       CLRA
+18F5 87       PSHA
+18F6 87       PSHA
+18F7 95       TSX
+18F8 89       PSHX
+19F9 8B       PSHH
+18FA AF 08    AIX #8
+18FC 89       PSHX
+18FD 8B       PSHH
+18FE 9E FE 03 LDHX 3,SP
+1901 CD 1A 2A JSR 0x1A2A ; 0x1A2A
+1904 95       TSX
+1905 AF 0E    AIX #14
+1907 CD 1A 30 JSR 0x1A30 ; 0x1A30
+190A A7 06    AIS #6
+190C C7 18 00 STA 0x1800 ; <----------- WATCHDOG
+190F 95       TSX
+1910 6C 03    INC 3,X
+1912 26 02    BNE *+4 ; 0x1916
+1914 6C 02    INC 2,X
+1916 9E FE 01 LDHX 1,SP
+1919 9E F3 03 CPHX 3,SP
+191C 22 BD    BHI *-65 ; 0x18DB
+
+ if(acc==tested_num)
+  { result[res_pos++]=tested_num; }
+ }
+}
+
+191E 9E F3 07 CPHX 7,SP
+1921 26 1D    BNE *+31 ; 0x1940
+1923 9E FE 05 LDHX 5,SP
+1926 26 18    BNE *+26 ; 0x1940
+1928 9E FE 09 LDHX 9,SP
+192B 89       PSHX
+192C AF 01    AIX #1
+192E 9E FF 0A STHX 10,SP
+1931 88       PULX
+1932 58       LSLX
+1933 9E E6 02 LDA 2,SP
+1936 8C       CLRH
+1937 D7 01 01 STA 257,X
+193A 9E E6 01 LDA 1,SP
+193D D7 01 00 STA 256,X
+1940 95       TSX
+1941 6C 01    INC 1,X
+1943 26 01    BNE *+3 ; 0x1946
+1945 7C       INC ,X
+1946 9E FE 01 LDHX 1,SP
+1949 65 00 01 CPHX #0x0001 <----------------- END_NUM
+194C 25 86    BCS *-120 ; 0x18D4
+194E A7 0A    AIS #10
+1950 81       RTS <------------- USCITA MAIN
+
+1951 5F       CLRX
+1952 8C       CLRH
+1953 9E FF 09 STHX 9,SP
+1956 8C       CLRH
+1957 9E FF 07 STHX 7,SP
+195A 5C       INCX
+195B 81       RTS <----------- FINE MAIN
+
+static void _PUSH_ARGS_L(void) { ... }
+195C E6 03    LDA 3,X
+195E 87       PSHA
+195F E6 02    LDA 2,X
+1961 87       PSHA
+1962 9E AE    LDHX ,X
+1964 89       PSHX
+1965 8B       PSHH
+1966 9E FE 07 LDHX 7,SP
+1969 E6 03    LDA 3,X
+196B 9E E7 11 STA 17,SP
+196E E6 02    LDA 2,X
+1970 9E E7 10 STA 16,SP
+1973 9E AE    LDHX ,X
+1975 9E FF 0E STHX 14,SP
+1978 9E FE 05 LDHX 5,SP
+197B FC       JMP ,X
+
+static void _ENTER_BINARY_L(void) { ... }
+197C 87       PSHA
+197D 89       PSHX
+197E 8B       PSHH
+197F 89       PSHX
+1980 8B       PSHH
+1981 9E FE 06 LDHX 6,SP
+1984 89       PSHX
+1985 8B       PSHH
+1986 9E FE 0A LDHX 10,SP
+1989 9E FF 08 STHX 8,SP
+198C 9E FE 0C LDHX 12,SP
+198F CC 19 5C JMP 0x195C
+
+static void _IDIVMOD (char dummy_sgn, int j, int dummy, int i, ...) { ... }
+1992 9E 6D 04 TST 4,SP
+1995 26 1A    BNE *+28 ; 0x19B1
+1997 95       TSX
+1998 E6 07    LDA 7,X
+199A EE 04    LDX 4,X
+199C 8C       CLRH
+199D 52       DIV
+199E 9E E7 04 STA 4,SP
+19A1 9E E6 09 LDA 9,SP
+19A4 52       DIV
+19A5 9E E7 05 STA 5,SP
+19A8 9E 6F 08 CLR 8,SP
+19AB 8B       PSHH
+19AC 86       PULA
+19AD 9E E7 09 STA 9,SP
+19B0 81       RTS
+19B1 4F       CLRA
+19B2 87       PSHA
+19B3 AE 08    LDX #0x08
+19B5 98       CLC
+19B6 9E 69 0A ROL 10,SP
+19B9 9E 69 09 ROL 9,SP
+19BC 9E 69 01 ROL 1,SP
+19BF 9E E6 05 LDA 5,SP
+19C2 9E E1 01 CMP 1,SP
+19C5 22 1D    BHI *+31 ; 0x19E4
+19C7 26 08    BNE *+10 ; 0x19D1
+19C9 9E E6 0E LDA 6,SP
+19CC 9E E1 09 CMP 9,SP
+19CF 22 13    BHI *+21 ; 0x19E4
+19D1 9E E6 09 LDA 9,SP
+19D4 9E E0 06 SUB 6,SP
+19D7 9E E7 09 STA 9,SP
+19DA 9E E6 01 LDA 1,SP
+19DD 9E E2 05 SBC 5,SP
+19E0 9E E7 01 STA 1,SP
+19E3 99       SEC
+19E4 5B D0    DBNZX *-46 ; 0x19B6
+19E6 9E E6 0A LDA 10,SP
+19E9 49       ROLA
+19EA 9E E7 06 STA 6,SP
+19ED 9E E6 09 LDA 9,SP
+19F0 9E E7 0A STA 10,SP
+19F3 86       PULA
+19F4 9E E7 08 STA 8,SP
+19F7 9E 6F 04 CLR 4,SP
+19FA 81       RTS
+
+static void _LADD_k_is_k_plus_j(_PARAM_BINARY_L) { ... }
+19FB 95       TSX
+19FC E6 12    LDA 18,X
+19FE EB 05    ADD 5,X
+1A00 E7 12    STA 18,X
+1A02 E6 11    LDA 17,X
+1A04 E9 04    ADC 4,X
+1A06 E7 11    STA 17,X
+1A08 E6 10    LDA 16,X
+1A0A E9 03    ADC 3,X
+1A0C E7 10    STA 16,X
+1A0E E6 0F    LDA 15,X
+1A10 E9 02    ADC 2,X
+1A12 E7 0F    STA 15,X
+1A14 A7 0A    AIS #10
+1A16 8A       PULH
+1A17 88       PULX
+1A18 86       PULA
+1A19 81       RTS
+
+void _IMODU_STAR08(int i, ...) { ... }
+1A1A A7 FE    AIS #-2
+1A1C 9E FF 01 STHX 1,SP
+1A1F 87       PSHA
+1A20 CD 19 92 JSR 0x1992 ; 0x1992
+1A23 86       PULA
+1A24 A7 02    AIS #2
+1A26 9E FE 03 LDHX 3,SP
+1A29 81       RTS
+
+void _LADD(void) { ... }
+1A2A CD 19 7C JSR 0x197C ; 0x197C
+1A2D CD 19 FB JSR 0x19FB ; 0x19FB
+
+void _POP32(void) { ... }
+1A30 87       PSHA
+1A31 9E E6 04 LDA 4,SP
+1A34 F7       STA ,X
+1A35 9E E6 05 LDA 5,SP
+1A38 E7 01    STA 1,X
+1A3A 9E E6 06 LDA 6,SP
+1A3D E7 02    STA 2,X
+1A3F 9E E6 07 LDA 7,SP
+1A42 E7 03    STA 3,X
+1A44 86       PULA
+1A45 8A       PULH
+1A46 88       PULX
+1A47 A7 04    AIS #4
+1A49 FC       JMP ,X
\ No newline at end of file
diff --git a/helm/software/matita/contribs/assembly/freescale/Doc/ordine_compilazione.txt b/helm/software/matita/contribs/assembly/freescale/Doc/ordine_compilazione.txt
new file mode 100755
index 000000000..9746e1c56
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/freescale/Doc/ordine_compilazione.txt
@@ -0,0 +1,32 @@
+
+tutte le definizioni fanno capo a
+ cic:/matita/freescale/...
+
+extra.ma
+exadecim.ma
+byte8.ma
+word16.ma
+aux_bases.ma
+opcode.ma
+table_HC05.ma
+table_HC05_tests.ma
+table_HC08.ma
+table_HC08_tests.ma
+table_HCS08.ma
+table_HCS08_tests.ma
+table_RS08.ma
+table_RS08_tests.ma
+translation.ma
+memory_struct.ma
+memory_func.ma
+memory_trees.ma
+memory_bits.ma
+memory_abs.ma
+status.ma
+model.ma
+load_write.ma
+multivm.ma
+micro_tests.ma
+medium_tests_tools.ma
+medium_tests_lemmas.ma
+medium_tests.ma
diff --git a/helm/software/matita/contribs/assembly/freescale/Doc/string_reverse.txt b/helm/software/matita/contribs/assembly/freescale/Doc/string_reverse.txt
new file mode 100755
index 000000000..c6992404d
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/freescale/Doc/string_reverse.txt
@@ -0,0 +1,99 @@
+
+A: 0x00 HX: 0x0D4B SP: 0x0D4A PC: 0x18E0 Z:1
+A: 0x00 HX: LUNG/2 SP: 0x0D4A PC: 0x192B Z:1
+
+   8: 178806 -> 179480 :   674 = 42+79*   8
+  16: 178806 -> 180112 :  1306 = 42+79*  16
+  32: 178806 -> 181376 :  2570 = 42+79*  32
+  64: 178806 -> 183904 :  5098 = 42+79*  64
+ 128: 178806 -> 188960 : 10154 = 42+79* 128
+ 256: 178806 -> 199072 : 20266 = 42+79* 256
+ 511: 178806 -> 219138 : 40332 = 42+79* 511
+ 512: 178806 -> 219301 : 40495 < 42+79* 512 = 40490
+ 514: 178806 -> 219459 : 40653 < 42+79* 514 = 40648
+1024: 178806 -> 259754 : 80948 > 42+79*1024 = 80938
+
+ottima definizione esatta del tempo di esecuzione!
+
+T(n)=42+79*n+5*(n/512) oppure T(n)=42+79*n+5*(n>>9)
+
+dati 0x100-> 3072 byte
+
+**********************************************
+
+static unsigned char dati[3072]={...};
+
+void swap(unsigned char *a, unsigned char *b)
+ { unsigned char tmp=*a; *a=*b; *b=tmp; return; }
+
+18BE       PSHX
+18BF       PSHH
+18C0       LDHX 5,SP
+18C3       LDA ,X
+18C4       LDHX 1,SP
+18C7       PSHA
+18C8       LDA ,X
+18C9       LDHX 6,SP
+18CC       STA ,X
+18CD       LDHX 2,SP
+18D0       PULA
+18D1       STA ,X
+18D2       AIS #2
+18D4       RTS
+
+18D5-18DF ...
+
+void main(void)
+{
+ unsigned int pos=0,limit=0;
+
+ for(limit=3072;pos<(limit/2);pos++)
+  { swap(&dati[pos],&dati[limit-pos-1]); }
+
+18E0       LDHX #LUNG
+18E3       STHX 4,SP
+18E6 20 32 BRA *+52 ; 191A
+18E8       TSX
+18E9       LDA 2,X
+18EB       ADD #0x00
+18ED       PSHA
+18EE       LDA 1,X
+18F0       ADC #0x01
+18F2       PSHA
+18F3       LDA 4,X
+18F5       SUB 2,X
+18F7       STA ,X
+18F8       LDA 3,X
+18FA       SBC 1,X
+18FC       PSHA
+18FD       LDX ,X
+18FE       PULH
+18FF       AIX #-1
+1901       TXA
+1902       ADD #0x00
+1904       PSHH
+1905       TSX
+1906       STA 3,X
+1908       PULA
+1909       ADC #0x01
+190B       LDX 3,X
+190D       PSHA
+190E       PULH
+190F AD AD BSR *-81 ; 18BE
+1911       AIS #2
+1913       TSX
+1914       INC 2,X
+1916 26 02 BNE *+4 ; 191A
+1918       INC 1,X
+191A       TSX
+191B       LDA 3,X
+191D       PSHA
+191E       PULH
+191F       LSRA
+1920       TSX
+1921       LDX 4,X
+1923       RORX
+1924       PSHA
+1925       PULH
+1926       CPHX 2,SP
+1929 22 BD BHI *-65 ; 18E8
diff --git a/helm/software/matita/contribs/assembly/freescale/aux_bases.ma b/helm/software/matita/contribs/assembly/freescale/aux_bases.ma
index 50314e9b1..f2d2a5ce5 100644
--- a/helm/software/matita/contribs/assembly/freescale/aux_bases.ma
+++ b/helm/software/matita/contribs/assembly/freescale/aux_bases.ma
@@ -47,7 +47,7 @@ definition exadecim_of_oct ≝
   [ o0 ⇒ x0 | o1 ⇒ x1 | o2 ⇒ x2 | o3 ⇒ x3
   | o4 ⇒ x4 | o5 ⇒ x5 | o6 ⇒ x6 | o7 ⇒ x7 ].
 
-coercion cic:/matita/freescale/aux_bases/exadecim_of_oct.con.
+coercion exadecim_of_oct.
 
 (* iteratore sugli ottali *)
 definition forall_oct ≝ λP.
@@ -104,7 +104,7 @@ definition byte8_of_bitrigesim ≝
   | t18 ⇒ 〈x1,x8〉 | t19 ⇒ 〈x1,x9〉 | t1A ⇒ 〈x1,xA〉 | t1B ⇒ 〈x1,xB〉
   | t1C ⇒ 〈x1,xC〉 | t1D ⇒ 〈x1,xD〉 | t1E ⇒ 〈x1,xE〉 | t1F ⇒ 〈x1,xF〉 ].
 
-coercion cic:/matita/freescale/aux_bases/byte8_of_bitrigesim.con.
+coercion byte8_of_bitrigesim.
 
 (* iteratore sui bitrigesimali *)
 definition forall_bitrigesim ≝ λP.
diff --git a/helm/software/matita/contribs/assembly/freescale/byte8.ma b/helm/software/matita/contribs/assembly/freescale/byte8.ma
index 6f1c48404..dfff4c8a8 100644
--- a/helm/software/matita/contribs/assembly/freescale/byte8.ma
+++ b/helm/software/matita/contribs/assembly/freescale/byte8.ma
@@ -150,7 +150,7 @@ definition MSB_b8 ≝ λb:byte8.eq_ex x8 (and_ex x8 (b8h b)).
 (* byte → naturali *)
 definition nat_of_byte8 ≝ λb:byte8.16*(b8h b) + (b8l b).
 
-coercion cic:/matita/freescale/byte8/nat_of_byte8.con.
+coercion nat_of_byte8.
 
 (* naturali → byte *)
 definition byte8_of_nat ≝ λn.mk_byte8 (exadecim_of_nat (n/16)) (exadecim_of_nat n).
diff --git a/helm/software/matita/contribs/assembly/freescale/exadecim.ma b/helm/software/matita/contribs/assembly/freescale/exadecim.ma
index 246ab983e..969c22a36 100644
--- a/helm/software/matita/contribs/assembly/freescale/exadecim.ma
+++ b/helm/software/matita/contribs/assembly/freescale/exadecim.ma
@@ -1450,7 +1450,7 @@ definition nat_of_exadecim ≝
   [ x0 ⇒ 0 | x1 ⇒ 1 | x2 ⇒ 2  | x3 ⇒ 3  | x4 ⇒ 4  | x5 ⇒ 5  | x6 ⇒ 6  | x7 ⇒ 7
   | x8 ⇒ 8 | x9 ⇒ 9 | xA ⇒ 10 | xB ⇒ 11 | xC ⇒ 12 | xD ⇒ 13 | xE ⇒ 14 | xF ⇒ 15 ].
 
-coercion cic:/matita/freescale/exadecim/nat_of_exadecim.con.
+coercion nat_of_exadecim.
 
 (* naturali → esadecimali *)
 let rec exadecim_of_nat n ≝
diff --git a/helm/software/matita/contribs/assembly/freescale/load_write.ma b/helm/software/matita/contribs/assembly/freescale/load_write.ma
index b288f9863..28c78b6bb 100644
--- a/helm/software/matita/contribs/assembly/freescale/load_write.ma
+++ b/helm/software/matita/contribs/assembly/freescale/load_write.ma
@@ -398,7 +398,7 @@ definition mode_IMM2_load ≝
 
 (* lettura da [byte [curpc]]: true=DIR1 loadb, false=DIR1 loadw *)
 definition mode_DIR1_load ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
  opt_map ?? (memory_filter_read m t s cur_pc)
   (λaddr.(aux_load m t byteflag) s 〈〈x0,x0〉:addr〉 cur_pc 1).
 
@@ -410,7 +410,7 @@ definition mode_DIR1n_load ≝
 
 (* scrittura su [byte [curpc]]: true=DIR1 writeb, false=DIR1 writew *)
 definition mode_DIR1_write ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
 λwritebw:match byteflag with [ true ⇒ byte8 | false ⇒ word16 ].
  opt_map ?? (memory_filter_read m t s cur_pc)
   (λaddr.(aux_write m t byteflag) s 〈〈x0,x0〉:addr〉 cur_pc 1 writebw).
@@ -423,14 +423,14 @@ definition mode_DIR1n_write ≝
 
 (* lettura da [word [curpc]]: true=DIR2 loadb, false=DIR2 loadw *)
 definition mode_DIR2_load ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
  opt_map ?? (memory_filter_read m t s cur_pc)
   (λaddrh.opt_map ?? (memory_filter_read m t s (filtered_inc_w16 m t s cur_pc))
    (λaddrl.(aux_load m t byteflag) s 〈addrh:addrl〉 cur_pc 2)).
 
 (* scrittura su [word [curpc]]: true=DIR2 writeb, false=DIR2 writew *)
 definition mode_DIR2_write ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
 λwritebw:match byteflag with [ true ⇒ byte8 | false ⇒ word16 ].
  opt_map ?? (memory_filter_read m t s cur_pc)
   (λaddrh.opt_map ?? (memory_filter_read m t s (filtered_inc_w16 m t s cur_pc))
@@ -446,20 +446,20 @@ definition get_IX ≝
 
 (* lettura da [IX]: true=IX0 loadb, false=IX0 loadw *)
 definition mode_IX0_load ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
  opt_map ?? (get_IX m t s)
   (λaddr.(aux_load m t byteflag) s addr cur_pc 0).
 
 (* scrittura su [IX]: true=IX0 writeb, false=IX0 writew *)
 definition mode_IX0_write ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
 λwritebw:match byteflag with [ true ⇒ byte8 | false ⇒ word16 ].
  opt_map ?? (get_IX m t s)
   (λaddr.(aux_write m t byteflag) s addr cur_pc 0 writebw).
 
 (* lettura da [IX+byte [pc]]: true=IX1 loadb, false=IX1 loadw *)
 definition mode_IX1_load ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
  opt_map ?? (get_IX m t s)
   (λaddr.opt_map ?? (memory_filter_read m t s cur_pc)
    (λoffs.(aux_load m t byteflag) s (plus_w16nc addr 〈〈x0,x0〉:offs〉) cur_pc 1)).
@@ -473,7 +473,7 @@ definition mode_IX1ADD_load ≝
 
 (* scrittura su [IX+byte [pc]]: true=IX1 writeb, false=IX1 writew *)
 definition mode_IX1_write ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
 λwritebw:match byteflag with [ true ⇒ byte8 | false ⇒ word16 ].
  opt_map ?? (get_IX m t s)
   (λaddr.opt_map ?? (memory_filter_read m t s cur_pc)
@@ -481,7 +481,7 @@ definition mode_IX1_write ≝
 
 (* lettura da [IX+word [pc]]: true=IX2 loadb, false=IX2 loadw *)
 definition mode_IX2_load ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
  opt_map ?? (get_IX m t s)
   (λaddr.opt_map ?? (memory_filter_read m t s cur_pc)
    (λoffsh.opt_map ?? (memory_filter_read m t s (filtered_inc_w16 m t s cur_pc))
@@ -497,7 +497,7 @@ definition mode_IX2ADD_load ≝
 
 (* scrittura su [IX+word [pc]]: true=IX2 writeb, false=IX2 writew *)
 definition mode_IX2_write ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
 λwritebw:match byteflag with [ true ⇒ byte8 | false ⇒ word16 ].
  opt_map ?? (get_IX m t s)
   (λaddr.opt_map ?? (memory_filter_read m t s cur_pc)
@@ -506,14 +506,14 @@ definition mode_IX2_write ≝
 
 (* lettura da [SP+byte [pc]]: true=SP1 loadb, false=SP1 loadw *)
 definition mode_SP1_load ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
  opt_map ?? (get_sp_reg m t s)
   (λaddr.opt_map ?? (memory_filter_read m t s cur_pc)
    (λoffs.(aux_load m t byteflag) s (plus_w16nc addr 〈〈x0,x0〉:offs〉) cur_pc 1)).
 
 (* scrittura su [SP+byte [pc]]: true=SP1 writeb, false=SP1 writew *)
 definition mode_SP1_write ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
 λwritebw:match byteflag with [ true ⇒ byte8 | false ⇒ word16 ].
  opt_map ?? (get_sp_reg m t s)
   (λaddr.opt_map ?? (memory_filter_read m t s cur_pc)
@@ -521,7 +521,7 @@ definition mode_SP1_write ≝
 
 (* lettura da [SP+word [pc]]: true=SP2 loadb, false=SP2 loadw *)
 definition mode_SP2_load ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
  opt_map ?? (get_sp_reg m t s)
   (λaddr.opt_map ?? (memory_filter_read m t s cur_pc)
    (λoffsh.opt_map ?? (memory_filter_read m t s (filtered_inc_w16 m t s cur_pc))
@@ -529,7 +529,7 @@ definition mode_SP2_load ≝
 
 (* scrittura su [SP+word [pc]]: true=SP2 writeb, false=SP2 writew *)
 definition mode_SP2_write ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.λs:any_status m t.λcur_pc:word16.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.λs:any_status m t.λcur_pc:word16.
 λwritebw:match byteflag with [ true ⇒ byte8 | false ⇒ word16 ].
  opt_map ?? (get_sp_reg m t s)
   (λaddr.opt_map ?? (memory_filter_read m t s cur_pc)
@@ -549,7 +549,7 @@ definition aux_inc_indX_16 ≝
 
 (* tutte le modalita' di lettura: false=loadb true=loadw *)
 definition multi_mode_load ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.
  match byteflag
  return λbyteflag:bool.any_status m t → word16 → instr_mode → 
   option (Prod3T (any_status m t) match byteflag with [ true ⇒ byte8 | false ⇒ word16 ] word16)
@@ -581,28 +581,28 @@ definition multi_mode_load ≝
 (* NO: solo lettura word *)
    | MODE_IMM2 ⇒ None ?
 (* preleva 1 byte da indirizzo diretto 1 byte *) 
-   | MODE_DIR1 ⇒ mode_DIR1_load m t true s cur_pc
+   | MODE_DIR1 ⇒ mode_DIR1_load true m t s cur_pc
 (* preleva 1 byte da indirizzo diretto 1 word *)
-   | MODE_DIR2 ⇒ mode_DIR2_load m t true s cur_pc
+   | MODE_DIR2 ⇒ mode_DIR2_load true m t s cur_pc
 (* preleva 1 byte da H:X *)
-   | MODE_IX0  ⇒ mode_IX0_load m t true s cur_pc
+   | MODE_IX0  ⇒ mode_IX0_load true m t s cur_pc
 (* preleva 1 byte da H:X+1 byte offset *)
-   | MODE_IX1  ⇒ mode_IX1_load m t true s cur_pc
+   | MODE_IX1  ⇒ mode_IX1_load true m t s cur_pc
 (* preleva 1 byte da H:X+1 word offset *)
-   | MODE_IX2  ⇒ mode_IX2_load m t true s cur_pc
+   | MODE_IX2  ⇒ mode_IX2_load true m t s cur_pc
 (* preleva 1 byte da SP+1 byte offset *)
-   | MODE_SP1  ⇒ mode_SP1_load m t true s cur_pc
+   | MODE_SP1  ⇒ mode_SP1_load true m t s cur_pc
 (* preleva 1 byte da SP+1 word offset *)
-   | MODE_SP2  ⇒ mode_SP2_load m t true s cur_pc
+   | MODE_SP2  ⇒ mode_SP2_load true m t s cur_pc
 
 (* come DIR1, chiamare scrittura per passo2: scrittura su DIR1 *)
-   | MODE_DIR1_to_DIR1 ⇒ mode_DIR1_load m t true s cur_pc
+   | MODE_DIR1_to_DIR1 ⇒ mode_DIR1_load true m t s cur_pc
 (* come IMM1, chiamare scrittura per passo2: scrittura su DIR1 *)
    | MODE_IMM1_to_DIR1 ⇒ mode_IMM1_load m t s cur_pc
 (* come IX0, chiamare scrittura per passo2: scrittura su DIR1 e X++ *)
-   | MODE_IX0p_to_DIR1 ⇒ mode_IX0_load m t true s cur_pc
+   | MODE_IX0p_to_DIR1 ⇒ mode_IX0_load true m t s cur_pc
 (* come DIR1, chiamare scrittura per passo2: scrittura su IX0 e X++ *)
-   | MODE_DIR1_to_IX0p ⇒ mode_DIR1_load m t true s cur_pc
+   | MODE_DIR1_to_IX0p ⇒ mode_DIR1_load true m t s cur_pc
 
 (* NO: solo lettura word/scrittura byte *)
    | MODE_INHA_and_IMM1 ⇒ None ?
@@ -660,19 +660,19 @@ definition multi_mode_load ≝
 (* preleva 1 word immediato *) 
    | MODE_IMM2 ⇒ mode_IMM2_load m t s cur_pc
 (* preleva 1 word da indirizzo diretto 1 byte *) 
-   | MODE_DIR1 ⇒ mode_DIR1_load m t false s cur_pc
+   | MODE_DIR1 ⇒ mode_DIR1_load false m t s cur_pc
 (* preleva 1 word da indirizzo diretto 1 word *) 
-   | MODE_DIR2 ⇒ mode_DIR2_load m t false s cur_pc
+   | MODE_DIR2 ⇒ mode_DIR2_load false m t s cur_pc
 (* preleva 1 word da H:X *)
-   | MODE_IX0  ⇒ mode_IX0_load m t false s cur_pc
+   | MODE_IX0  ⇒ mode_IX0_load false m t s cur_pc
 (* preleva 1 word da H:X+1 byte offset *)
-   | MODE_IX1  ⇒ mode_IX1_load m t false s cur_pc
+   | MODE_IX1  ⇒ mode_IX1_load false m t s cur_pc
 (* preleva 1 word da H:X+1 word offset *)
-   | MODE_IX2  ⇒ mode_IX2_load m t false s cur_pc
+   | MODE_IX2  ⇒ mode_IX2_load false m t s cur_pc
 (* preleva 1 word da SP+1 byte offset *)
-   | MODE_SP1  ⇒ mode_SP1_load m t false s cur_pc
+   | MODE_SP1  ⇒ mode_SP1_load false m t s cur_pc
 (* preleva 1 word da SP+1 word offset *)
-   | MODE_SP2  ⇒ mode_SP2_load m t false s cur_pc
+   | MODE_SP2  ⇒ mode_SP2_load false m t s cur_pc
 
 (* NO: solo lettura/scrittura byte *)
    | MODE_DIR1_to_DIR1 ⇒ None ?
@@ -703,7 +703,7 @@ definition multi_mode_load ≝
                                [ tripleT _ immb2 cur_pc'' ⇒
                                 Some ? (tripleT ??? s 〈immb1:immb2〉 cur_pc'')])])
 (* preleva 2 byte, possibilita' modificare Io argomento *)
-   | MODE_DIR1_and_IMM1 ⇒ opt_map ?? (mode_DIR1_load m t true s cur_pc)
+   | MODE_DIR1_and_IMM1 ⇒ opt_map ?? (mode_DIR1_load true m t s cur_pc)
                            (λS_dirb_and_PC.match S_dirb_and_PC with
                             [ tripleT _ dirb cur_pc' ⇒
                              opt_map ?? (mode_IMM1_load m t s cur_pc')
@@ -711,7 +711,7 @@ definition multi_mode_load ≝
                                [ tripleT _ immb cur_pc'' ⇒
                                 Some ? (tripleT ??? s 〈dirb:immb〉 cur_pc'')])])
 (* preleva 2 byte, possibilita' modificare Io argomento *)
-   | MODE_IX0_and_IMM1  ⇒ opt_map ?? (mode_IX0_load m t true s cur_pc)
+   | MODE_IX0_and_IMM1  ⇒ opt_map ?? (mode_IX0_load true m t s cur_pc)
                            (λS_ixb_and_PC.match S_ixb_and_PC with
                             [ tripleT _ ixb cur_pc' ⇒
                              opt_map ?? (mode_IMM1_load m t s cur_pc')
@@ -719,7 +719,7 @@ definition multi_mode_load ≝
                                [ tripleT _ immb cur_pc'' ⇒
                                 Some ? (tripleT ??? s 〈ixb:immb〉 cur_pc'')])])
 (* preleva 2 byte, H:X++, NO possibilita' modificare Io argomento *)
-   | MODE_IX0p_and_IMM1 ⇒ opt_map ?? (mode_IX0_load m t true s cur_pc)
+   | MODE_IX0p_and_IMM1 ⇒ opt_map ?? (mode_IX0_load true m t s cur_pc)
                            (λS_ixb_and_PC.match S_ixb_and_PC with
                             [ tripleT _ ixb cur_pc' ⇒
                              opt_map ?? (mode_IMM1_load m t s cur_pc')
@@ -729,7 +729,7 @@ definition multi_mode_load ≝
                                 opt_map ?? (aux_inc_indX_16 m t s)
                                  (λs'.Some ? (tripleT ??? s' 〈ixb:immb〉 cur_pc''))])])
 (* preleva 2 byte, possibilita' modificare Io argomento *)
-   | MODE_IX1_and_IMM1  ⇒ opt_map ?? (mode_IX1_load m t true s cur_pc)
+   | MODE_IX1_and_IMM1  ⇒ opt_map ?? (mode_IX1_load true m t s cur_pc)
                            (λS_ixb_and_PC.match S_ixb_and_PC with
                             [ tripleT _ ixb cur_pc' ⇒
                              opt_map ?? (mode_IMM1_load m t s cur_pc')
@@ -737,7 +737,7 @@ definition multi_mode_load ≝
                                [ tripleT _ immb cur_pc'' ⇒
                                 Some ? (tripleT ??? s 〈ixb:immb〉 cur_pc'')])])
 (* preleva 2 byte, H:X++, NO possibilita' modificare Io argomento *)
-   | MODE_IX1p_and_IMM1 ⇒ opt_map ?? (mode_IX1_load m t true s cur_pc)
+   | MODE_IX1p_and_IMM1 ⇒ opt_map ?? (mode_IX1_load true m t s cur_pc)
                            (λS_ixb_and_PC.match S_ixb_and_PC with
                             [ tripleT _ ixb cur_pc' ⇒
                              opt_map ?? (mode_IMM1_load m t s cur_pc')
@@ -747,7 +747,7 @@ definition multi_mode_load ≝
                                 opt_map ?? (aux_inc_indX_16 m t s)
                                  (λs'.Some ? (tripleT ??? s' 〈ixb:immb〉 cur_pc''))])])
 (* preleva 2 byte, possibilita' modificare Io argomento *)
-   | MODE_SP1_and_IMM1  ⇒ opt_map ?? (mode_SP1_load m t true s cur_pc)
+   | MODE_SP1_and_IMM1  ⇒ opt_map ?? (mode_SP1_load true m t s cur_pc)
                            (λS_spb_and_PC.match S_spb_and_PC with
                             [ tripleT _ spb cur_pc' ⇒
                              opt_map ?? (mode_IMM1_load m t s cur_pc')
@@ -778,7 +778,7 @@ definition multi_mode_load ≝
 
 (* tutte le modalita' di scrittura: true=writeb, false=writew *)
 definition multi_mode_write ≝
-λm:mcu_type.λt:memory_impl.λbyteflag:bool.match byteflag
+λbyteflag:bool.λm:mcu_type.λt:memory_impl.match byteflag
  return λbyteflag:bool.any_status m t → word16 → instr_mode →
   match byteflag with [ true ⇒ byte8 | false ⇒ word16 ] →
   option (Prod (any_status m t) word16) with
@@ -809,32 +809,32 @@ definition multi_mode_write ≝
 (* NO: solo lettura word *)
   | MODE_IMM2       ⇒ None ?
 (* scrive 1 byte su indirizzo diretto 1 byte *)
-  | MODE_DIR1       ⇒ mode_DIR1_write m t true s cur_pc writeb
+  | MODE_DIR1       ⇒ mode_DIR1_write true m t s cur_pc writeb
 (* scrive 1 byte su indirizzo diretto 1 word *)
-  | MODE_DIR2       ⇒ mode_DIR2_write m t true s cur_pc writeb
+  | MODE_DIR2       ⇒ mode_DIR2_write true m t s cur_pc writeb
 (* scrive 1 byte su H:X *)
-  | MODE_IX0        ⇒ mode_IX0_write m t true s cur_pc writeb
+  | MODE_IX0        ⇒ mode_IX0_write true m t s cur_pc writeb
 (* scrive 1 byte su H:X+1 byte offset *)
-  | MODE_IX1        ⇒ mode_IX1_write m t true s cur_pc writeb
+  | MODE_IX1        ⇒ mode_IX1_write true m t s cur_pc writeb
 (* scrive 1 byte su H:X+1 word offset *)
-  | MODE_IX2        ⇒ mode_IX2_write m t true s cur_pc writeb
+  | MODE_IX2        ⇒ mode_IX2_write true m t s cur_pc writeb
 (* scrive 1 byte su SP+1 byte offset *)
-  | MODE_SP1        ⇒ mode_SP1_write m t true s cur_pc writeb
+  | MODE_SP1        ⇒ mode_SP1_write true m t s cur_pc writeb
 (* scrive 1 byte su SP+1 word offset *)
-  | MODE_SP2        ⇒ mode_SP2_write m t true s cur_pc writeb
+  | MODE_SP2        ⇒ mode_SP2_write true m t s cur_pc writeb
 
 (* passo2: scrittura su DIR1, passo1: lettura da DIR1 *)
-  | MODE_DIR1_to_DIR1   ⇒ mode_DIR1_write m t true s cur_pc writeb
+  | MODE_DIR1_to_DIR1   ⇒ mode_DIR1_write true m t s cur_pc writeb
 (* passo2: scrittura su DIR1, passo1: lettura da IMM1 *)
-  | MODE_IMM1_to_DIR1   ⇒ mode_DIR1_write m t true s cur_pc writeb
+  | MODE_IMM1_to_DIR1   ⇒ mode_DIR1_write true m t s cur_pc writeb
 (* passo2: scrittura su DIR1 e X++, passo1: lettura da IX0 *)
-  | MODE_IX0p_to_DIR1   ⇒ opt_map ?? (mode_DIR1_write m t true s cur_pc writeb)
+  | MODE_IX0p_to_DIR1   ⇒ opt_map ?? (mode_DIR1_write true m t s cur_pc writeb)
                            (λS_and_PC.match S_and_PC with [ pair S_op PC_op ⇒
                             (* H:X++ *)
                             opt_map ?? (aux_inc_indX_16 m t S_op)
                              (λS_op'.Some ? (pair ?? S_op' PC_op))])
 (* passo2: scrittura su IX0 e X++, passo1: lettura da DIR1 *)
-  | MODE_DIR1_to_IX0p   ⇒ opt_map ?? (mode_IX0_write m t true s cur_pc writeb)
+  | MODE_DIR1_to_IX0p   ⇒ opt_map ?? (mode_IX0_write true m t s cur_pc writeb)
                            (λS_and_PC.match S_and_PC with [ pair S_op PC_op ⇒
                             (* H:X++ *)
                             opt_map ?? (aux_inc_indX_16 m t S_op)
@@ -848,17 +848,17 @@ definition multi_mode_write ≝
 (* NO: solo lettura word *) 
   | MODE_IMM1_and_IMM1 ⇒ None ?
 (* dopo aver prelevato 2 byte la possibilita' modificare Io argomento = DIR1 *) 
-  | MODE_DIR1_and_IMM1 ⇒ mode_DIR1_write m t true s cur_pc writeb
+  | MODE_DIR1_and_IMM1 ⇒ mode_DIR1_write true m t s cur_pc writeb
 (* dopo aver prelevato 2 byte la possibilita' modificare Io argomento = IX0 *)
-  | MODE_IX0_and_IMM1  ⇒ mode_IX0_write m t true s cur_pc writeb
+  | MODE_IX0_and_IMM1  ⇒ mode_IX0_write true m t s cur_pc writeb
 (* NO: solo lettura word *) 
   | MODE_IX0p_and_IMM1 ⇒ None ?
 (* dopo aver prelevato 2 byte la possibilita' modificare Io argomento = IX1 *)
-  | MODE_IX1_and_IMM1  ⇒ mode_IX1_write m t true s cur_pc writeb
+  | MODE_IX1_and_IMM1  ⇒ mode_IX1_write true m t s cur_pc writeb
 (* NO: solo lettura word *) 
   | MODE_IX1p_and_IMM1 ⇒ None ?
 (* dopo aver prelevato 2 byte la possibilita' modificare Io argomento = SP1 *)
-  | MODE_SP1_and_IMM1  ⇒ mode_SP1_write m t true s cur_pc writeb
+  | MODE_SP1_and_IMM1  ⇒ mode_SP1_write true m t s cur_pc writeb
 
 (* scrive 1 byte, ma la scrittura avviene solo per n-simo bit = leggi/modifica bit/scrivi *)
   | MODE_DIRn msk ⇒ mode_DIR1n_write m t s cur_pc msk (getn_array8T msk bool (bits_of_byte8 writeb))   
@@ -895,19 +895,19 @@ definition multi_mode_write ≝
 (* NO: solo lettura word *)
   | MODE_IMM2       ⇒ None ?
 (* scrive 1 word su indirizzo diretto 1 byte *) 
-  | MODE_DIR1       ⇒ mode_DIR1_write m t false s cur_pc writew
+  | MODE_DIR1       ⇒ mode_DIR1_write false m t s cur_pc writew
 (* scrive 1 word su indirizzo diretto 1 word *)
-  | MODE_DIR2       ⇒ mode_DIR2_write m t false s cur_pc writew
+  | MODE_DIR2       ⇒ mode_DIR2_write false m t s cur_pc writew
 (* scrive 1 word su H:X *)
-  | MODE_IX0        ⇒ mode_IX0_write m t false s cur_pc writew
+  | MODE_IX0        ⇒ mode_IX0_write false m t s cur_pc writew
 (* scrive 1 word su H:X+1 byte offset *)
-  | MODE_IX1        ⇒ mode_IX1_write m t false s cur_pc writew
+  | MODE_IX1        ⇒ mode_IX1_write false m t s cur_pc writew
 (* scrive 1 word su H:X+1 word offset *)
-  | MODE_IX2        ⇒ mode_IX2_write m t false s cur_pc writew
+  | MODE_IX2        ⇒ mode_IX2_write false m t s cur_pc writew
 (* scrive 1 word su SP+1 byte offset *)
-  | MODE_SP1        ⇒ mode_SP1_write m t false s cur_pc writew
+  | MODE_SP1        ⇒ mode_SP1_write false m t s cur_pc writew
 (* scrive 1 word su SP+1 word offset *)
-  | MODE_SP2        ⇒ mode_SP2_write m t false s cur_pc writew
+  | MODE_SP2        ⇒ mode_SP2_write false m t s cur_pc writew
 
 (* NO: solo lettura/scrittura byte *)
   | MODE_DIR1_to_DIR1 ⇒ None ?
diff --git a/helm/software/matita/contribs/assembly/freescale/model.ma b/helm/software/matita/contribs/assembly/freescale/model.ma
index 7ab85a5c7..5cf20ea71 100644
--- a/helm/software/matita/contribs/assembly/freescale/model.ma
+++ b/helm/software/matita/contribs/assembly/freescale/model.ma
@@ -87,10 +87,10 @@ inductive any_mcu_model : Type ≝
 | FamilyHCS08 : HCS08_mcu_model → any_mcu_model
 | FamilyRS08  : RS08_mcu_model → any_mcu_model.
 
-coercion cic:/matita/freescale/model/any_mcu_model.ind#xpointer(1/1/1).
-coercion cic:/matita/freescale/model/any_mcu_model.ind#xpointer(1/1/2).
-coercion cic:/matita/freescale/model/any_mcu_model.ind#xpointer(1/1/3).
-coercion cic:/matita/freescale/model/any_mcu_model.ind#xpointer(1/1/4).
+coercion FamilyHC05.
+coercion FamilyHC08.
+coercion FamilyHCS08.
+coercion FamilyRS08.
 
 (* 
 condizioni errore interne alla MCU
diff --git a/helm/software/matita/contribs/assembly/freescale/multivm.ma b/helm/software/matita/contribs/assembly/freescale/multivm.ma
index 00de15cfa..b78efba70 100644
--- a/helm/software/matita/contribs/assembly/freescale/multivm.ma
+++ b/helm/software/matita/contribs/assembly/freescale/multivm.ma
@@ -45,7 +45,7 @@ include "freescale/load_write.ma".
 definition execute_ADC_ADD_aux ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.λsetflag:bool.
 λfAMC:byte8 → byte8 → bool → Prod byte8 bool.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     let A_op ≝ get_acc_8_low_reg m t s_tmp1 in
@@ -74,7 +74,7 @@ definition execute_ADC_ADD_aux ≝
 definition execute_AND_BIT_EOR_ORA_aux ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.λsetflag:bool.
 λfAM:byte8 → byte8 → byte8.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     let R_op ≝ fAM (get_acc_8_low_reg m t s_tmp1) M_op in
@@ -94,12 +94,12 @@ definition execute_AND_BIT_EOR_ORA_aux ≝
 definition execute_ASL_ASR_LSR_ROL_ROR_aux ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
 λfMC:byte8 → bool → Prod byte8 bool.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op _ ⇒
     match fMC M_op (get_c_flag m t s_tmp1) with [ pair R_op carry ⇒
     (* M = fMC(M,C) *)
-    opt_map ?? (multi_mode_write m t true s_tmp1 cur_pc i R_op)
+    opt_map ?? (multi_mode_write true m t s_tmp1 cur_pc i R_op)
      (λS_PC.match S_PC with
       [ pair s_tmp2 new_pc ⇒
       (* C = carry *)
@@ -126,7 +126,7 @@ definition branched_pc ≝
 (* tutti i branch calcoleranno la condizione e la passeranno qui *)
 definition execute_any_BRANCH ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.λfCOND:bool.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     (* if true, branch *) 
@@ -141,7 +141,7 @@ definition execute_any_BRANCH ≝
 definition execute_BCLRn_BSETn_aux ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.λoptval:byte8.
  (* Mn = filtered optval *)
- opt_map ?? (multi_mode_write m t true s cur_pc i optval)
+ opt_map ?? (multi_mode_write true m t s cur_pc i optval)
   (λS_PC.match S_PC with
    (* newpc = nextpc *)
    [ pair s_tmp1 new_pc ⇒ Some ? (pair ?? s_tmp1 new_pc) ]).
@@ -150,7 +150,7 @@ definition execute_BCLRn_BSETn_aux ≝
 (* il chiamante passa la logica da testare (0x00,¬0x00) e poi si salta *)
 definition execute_BRCLRn_BRSETn_aux ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.λfCOND:byte8 → bool.
- opt_map ?? (multi_mode_load m t false s cur_pc i)
+ opt_map ?? (multi_mode_load false m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒ match M_op with
     [ mk_word16 MH_op ML_op ⇒
@@ -166,12 +166,12 @@ definition execute_BRCLRn_BRSETn_aux ≝
 definition execute_COM_DEC_INC_NEG_aux ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
 λfM:byte8 → byte8.λfV:bool → bool → bool.λfC:bool → byte8 → bool.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op _ ⇒
     let R_op ≝ fM M_op in
     (* M = fM(M) *)
-    opt_map ?? (multi_mode_write m t true s_tmp1 cur_pc i R_op)
+    opt_map ?? (multi_mode_write true m t s_tmp1 cur_pc i R_op)
      (λS_PC.match S_PC with
       [ pair s_tmp2 new_pc ⇒
       (* C = fCR (C,R) *)
@@ -191,7 +191,7 @@ definition execute_COM_DEC_INC_NEG_aux ≝
 definition execute_SBC_SUB_aux ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.λsetflag:bool.
 λfAMC:byte8 → byte8 → bool → Prod byte8 bool.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     let A_op ≝ get_acc_8_low_reg m t s_tmp1 in
@@ -282,7 +282,7 @@ definition execute_ADD ≝
 (* SP += extended M *)
 definition execute_AIS ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
    opt_map ?? (get_sp_reg m t s_tmp1)
@@ -293,7 +293,7 @@ definition execute_AIS ≝
 (* H:X += extended M *)
 definition execute_AIX ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
    opt_map ?? (get_indX_16_reg m t s_tmp1)
@@ -468,7 +468,7 @@ definition execute_BSETn ≝
 (* HC05/HC08/HCS08 si appoggiano allo stack, RS08 a SPC *)
 definition execute_BSR ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t .λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒ let aux ≝
     (* push (new_pc low) *)
@@ -489,7 +489,7 @@ definition execute_BSR ≝
 (* if A=M, branch *)
 definition execute_CBEQA ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t false s cur_pc i)
+ opt_map ?? (multi_mode_load false m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     match M_op with
@@ -505,7 +505,7 @@ definition execute_CBEQA ≝
 (* if X=M, branch *)
 definition execute_CBEQX ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t false s cur_pc i)
+ opt_map ?? (multi_mode_load false m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     match M_op with
@@ -534,7 +534,7 @@ definition execute_CLI ≝
 definition execute_CLR ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
  (* M = 0 *)
- opt_map ?? (multi_mode_write m t true s cur_pc i 〈x0,x0〉)
+ opt_map ?? (multi_mode_write true m t s cur_pc i 〈x0,x0〉)
   (λS_PC.match S_PC with
    [ pair s_tmp1 new_pc ⇒
    (* Z = 1 *)
@@ -563,7 +563,7 @@ definition execute_COM ≝
 (* flags = H:X - M *)
 definition execute_CPHX ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t false s cur_pc i)
+ opt_map ?? (multi_mode_load false m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     opt_map ?? (get_indX_16_reg m t s_tmp1)
@@ -585,7 +585,7 @@ definition execute_CPHX ≝
 (* flags = X - M *)
 definition execute_CPX ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     opt_map ?? (get_indX_8_low_reg m t s_tmp1)
@@ -629,14 +629,14 @@ definition execute_DAA ≝
 (* if (--M)≠0, branch *)
 definition execute_DBNZ ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t false s cur_pc i)
+ opt_map ?? (multi_mode_load false m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     match M_op with
      [ mk_word16 MH_op ML_op ⇒
      (* --M *)
      let MH_op' ≝ pred_b8 MH_op in
-     opt_map ?? (multi_mode_write m t true s_tmp1 cur_pc i MH_op')
+     opt_map ?? (multi_mode_write true m t s_tmp1 cur_pc i MH_op')
       (λS_PC.match S_PC with
        [ pair s_tmp2 _ ⇒
         (* if (--M)≠0, branch *)
@@ -695,7 +695,7 @@ definition execute_INC ≝
 (* jmp, il nuovo indirizzo e' una WORD *)
 definition execute_JMP ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t false s cur_pc i)
+ opt_map ?? (multi_mode_load false m t s cur_pc i)
   (λS_M_PC.
    (* newpc = M_op *)
    Some ? (pair ?? (fst3T ??? S_M_PC) (snd3T ??? S_M_PC))).
@@ -704,7 +704,7 @@ definition execute_JMP ≝
 (* HC05/HC08/HCS08 si appoggiano allo stack, RS08 a SPC *)
 definition execute_JSR ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t false s cur_pc i)
+ opt_map ?? (multi_mode_load false m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒ let aux ≝
     (* push (new_pc low) *)
@@ -725,7 +725,7 @@ definition execute_JSR ≝
 (* A = M *)
 definition execute_LDA ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     (* A = M *) 
@@ -742,7 +742,7 @@ definition execute_LDA ≝
 (* H:X = M *)
 definition execute_LDHX ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t false s cur_pc i)
+ opt_map ?? (multi_mode_load false m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     opt_map ?? (set_indX_16_reg m t s_tmp1 M_op)
@@ -759,7 +759,7 @@ definition execute_LDHX ≝
 (* X = M *)
 definition execute_LDX ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     opt_map ?? (set_indX_8_low_reg m t s_tmp1 M_op)
@@ -782,11 +782,11 @@ definition execute_LSR ≝
 definition execute_MOV ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
  (* R_op = M1 *)
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_R_PC.match S_R_PC with
    [ tripleT s_tmp1 R_op tmp_pc ⇒
     (* M2 = R_op *)
-    opt_map ?? (multi_mode_write m t true s_tmp1 tmp_pc i R_op)
+    opt_map ?? (multi_mode_write true m t s_tmp1 tmp_pc i R_op)
      (λS_PC.match S_PC with
       [ pair s_tmp2 new_pc ⇒
        (* Z = nR7&nR6&nR5&nR4&nR3&nR2&nR1&nR0 *)
@@ -983,7 +983,7 @@ definition execute_STA ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
  (* M = A *)
  let A_op ≝ (get_acc_8_low_reg m t s) in
- opt_map ?? (multi_mode_write m t true s cur_pc i A_op)
+ opt_map ?? (multi_mode_write true m t s cur_pc i A_op)
   (λS_op_and_PC.match S_op_and_PC with
    [ pair s_tmp1 new_pc ⇒
    (* Z = nA7&nA6&nA5&nA4&nA3&nA2&nA1&nA0 *)
@@ -1000,7 +1000,7 @@ definition execute_STHX ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
  (* M = H:X *)
  opt_map ?? (get_indX_16_reg m t s)
-  (λX_op.opt_map ?? (multi_mode_write m t false s cur_pc i X_op)
+  (λX_op.opt_map ?? (multi_mode_write false m t s cur_pc i X_op)
    (λS_op_and_PC.match S_op_and_PC with
     [ pair s_tmp1 new_pc ⇒
      (* Z = nR15&nR14&nR13nR12&nR11&nR10&nR9&nR8nR7&nR6&nR5&nR4&nR3&nR2&nR1&nR0 *)
@@ -1022,7 +1022,7 @@ definition execute_STX ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
  (* M = X *)
  opt_map ?? (get_indX_8_low_reg m t s)
-  (λX_op.opt_map ?? (multi_mode_write m t true s cur_pc i X_op)
+  (λX_op.opt_map ?? (multi_mode_write true m t s cur_pc i X_op)
    (λS_op_and_PC.match S_op_and_PC with
     [ pair s_tmp1 new_pc ⇒
      (* Z = nR7&nR6&nR5&nR4&nR3&nR2&nR1&nR0 *)
@@ -1085,7 +1085,7 @@ definition execute_TPA ≝
    e' immediata *)
 definition execute_TST ≝
 λm:mcu_type.λt:memory_impl.λs:any_status m t.λi:instr_mode.λcur_pc:word16.
- opt_map ?? (multi_mode_load m t true s cur_pc i)
+ opt_map ?? (multi_mode_load true m t s cur_pc i)
   (λS_M_PC.match S_M_PC with
    [ tripleT s_tmp1 M_op new_pc ⇒
     (* Z = nR7&nR6&nR5&nR4&nR3&nR2&nR1&nR0 *)
diff --git a/helm/software/matita/contribs/assembly/freescale/opcode.ma b/helm/software/matita/contribs/assembly/freescale/opcode.ma
index 47312085f..fc30ddeb4 100644
--- a/helm/software/matita/contribs/assembly/freescale/opcode.ma
+++ b/helm/software/matita/contribs/assembly/freescale/opcode.ma
@@ -216,15 +216,15 @@ inductive opcode: Type ≝
 inductive any_opcode (m:mcu_type) : Type ≝
  anyOP : opcode → any_opcode m.
 
-coercion cic:/matita/freescale/opcode/any_opcode.ind#xpointer(1/1/1).
+coercion anyOP.
 
 (* raggruppamento di byte e word in un tipo unico *)
 inductive byte8_or_word16 : Type ≝
   Byte: byte8  → byte8_or_word16
 | Word: word16 → byte8_or_word16.
 
-coercion cic:/matita/freescale/opcode/byte8_or_word16.ind#xpointer(1/1/1).
-coercion cic:/matita/freescale/opcode/byte8_or_word16.ind#xpointer(1/1/2).
+coercion Byte.
+coercion Word.
 
 (* opcode → naturali, per usare eqb *)
 definition magic_of_opcode ≝
diff --git a/helm/software/matita/contribs/assembly/freescale/translation.ma b/helm/software/matita/contribs/assembly/freescale/translation.ma
index 0463cff55..be1c2038c 100644
--- a/helm/software/matita/contribs/assembly/freescale/translation.ma
+++ b/helm/software/matita/contribs/assembly/freescale/translation.ma
@@ -73,7 +73,7 @@ definition full_info_of_word16 ≝
 inductive t_byte8 (m:mcu_type) : Type ≝
  TByte : byte8 → t_byte8 m.
 
-coercion cic:/matita/freescale/translation/t_byte8.ind#xpointer(1/1/1).
+coercion TByte.
 
 (* introduzione di un tipo dipendente (dalla modalita') per gli argomenti *)
 inductive MA_check : instr_mode → Type ≝
@@ -117,7 +117,7 @@ inductive MA_check : instr_mode → Type ≝
 inductive instruction : Type ≝ 
 instr: ∀i:instr_mode.opcode → MA_check i → instruction.
 
-coercion cic:/matita/freescale/translation/instruction.ind#xpointer(1/1/1).
+coercion instr.
 
 (* picker: trasforma l'argomento necessario in input a bytes_of_pseudo_instr_mode_param:
    MA_check i → list (t_byte8 m) *)
diff --git a/helm/software/matita/contribs/assembly/freescale/word16.ma b/helm/software/matita/contribs/assembly/freescale/word16.ma
index c47ff7d51..d5bdd68bf 100644
--- a/helm/software/matita/contribs/assembly/freescale/word16.ma
+++ b/helm/software/matita/contribs/assembly/freescale/word16.ma
@@ -150,7 +150,7 @@ definition MSB_w16 ≝ λw:word16.eq_ex x8 (and_ex x8 (b8h (w16h w))).
 (* word → naturali *)
 definition nat_of_word16 ≝ λw:word16. 256 * (w16h w) + (nat_of_byte8 (w16l w)).
 
-coercion cic:/matita/freescale/word16/nat_of_word16.con.
+coercion nat_of_word16.
 
 (* naturali → word *)
 definition word16_of_nat ≝
diff --git a/helm/software/matita/contribs/assembly/freescale/word32.ma b/helm/software/matita/contribs/assembly/freescale/word32.ma
new file mode 100755
index 000000000..b84d928ef
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/freescale/word32.ma
@@ -0,0 +1,224 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "freescale/word16.ma".
+
+(* *********************** *)
+(* DEFINIZIONE DELLE DWORD *)
+(* *********************** *)
+
+record word32 : Type ≝
+ {
+ w32h: word16;
+ w32l: word16
+ }.
+
+(* \langle \rangle *)
+notation "〈x.y〉" non associative with precedence 80
+ for @{ 'mk_word32 $x $y }.
+interpretation "mk_word32" 'mk_word32 x y = (mk_word32 x y).
+
+(* operatore = *)
+definition eq_w32 ≝ λw1,w2.(eq_w16 (w32h w1) (w32h w2)) ⊗ (eq_w16 (w32l w1) (w32l w2)).
+
+(* operatore < *)
+definition lt_w32 ≝
+λw1,w2:word32.match lt_w16 (w32h w1) (w32h w2) with
+ [ true ⇒ true
+ | false ⇒ match gt_w16 (w32h w1) (w32h w2) with
+  [ true ⇒ false
+  | false ⇒ lt_w16 (w32l w1) (w32l w2) ]].
+
+(* operatore ≤ *)
+definition le_w32 ≝ λw1,w2:word32.(eq_w32 w1 w2) ⊕ (lt_w32 w1 w2).
+
+(* operatore > *)
+definition gt_w32 ≝ λw1,w2:word32.⊖ (le_w32 w1 w2).
+
+(* operatore ≥ *)
+definition ge_w32 ≝ λw1,w2:word32.⊖ (lt_w32 w1 w2).
+
+(* operatore and *)
+definition and_w32 ≝
+λw1,w2:word32.mk_word32 (and_w16 (w32h w1) (w32h w2)) (and_w16 (w32l w1) (w32l w2)).
+
+(* operatore or *)
+definition or_w32 ≝
+λw1,w2:word32.mk_word32 (or_w16 (w32h w1) (w32h w2)) (or_w16 (w32l w1) (w32l w2)).
+
+(* operatore xor *)
+definition xor_w32 ≝
+λw1,w2:word32.mk_word32 (xor_w16 (w32h w1) (w32h w2)) (xor_w16 (w32l w1) (w32l w2)).
+
+(* operatore rotazione destra con carry *)
+definition rcr_w32 ≝
+λw:word32.λc:bool.match rcr_w16 (w32h w) c with
+ [ pair wh' c' ⇒ match rcr_w16 (w32l w) c' with
+  [ pair wl' c'' ⇒ pair ?? (mk_word32 wh' wl') c'' ]]. 
+
+(* operatore shift destro *)
+definition shr_w32 ≝
+λw:word32.match rcr_w16 (w32h w) false with
+ [ pair wh' c' ⇒ match rcr_w16 (w32l w) c' with
+  [ pair wl' c'' ⇒ pair ?? (mk_word32 wh' wl') c'' ]].
+
+(* operatore rotazione destra *)
+definition ror_w32 ≝
+λw:word32.match rcr_w16 (w32h w) false with
+ [ pair wh' c' ⇒ match rcr_w16 (w32l w) c' with
+  [ pair wl' c'' ⇒ match c'' with
+   [ true ⇒ mk_word32 (or_w16 (mk_word16 (mk_byte8 x8 x0) (mk_byte8 x0 x0)) wh') wl'
+   | false ⇒ mk_word32 wh' wl' ]]].
+
+(* operatore rotazione destra n-volte *)
+let rec ror_w32_n (w:word32) (n:nat) on n ≝
+ match n with
+  [ O ⇒ w
+  | S n' ⇒ ror_w32_n (ror_w32 w) n' ].
+
+(* operatore rotazione sinistra con carry *)
+definition rcl_w32 ≝
+λw:word32.λc:bool.match rcl_w16 (w32l w) c with
+ [ pair wl' c' ⇒ match rcl_w16 (w32h w) c' with
+  [ pair wh' c'' ⇒ pair ?? (mk_word32 wh' wl') c'' ]]. 
+
+(* operatore shift sinistro *)
+definition shl_w32 ≝
+λw:word32.match rcl_w16 (w32l w) false with
+ [ pair wl' c' ⇒ match rcl_w16 (w32h w) c' with
+  [ pair wh' c'' ⇒ pair ?? (mk_word32 wh' wl') c'' ]].
+
+(* operatore rotazione sinistra *)
+definition rol_w32 ≝
+λw:word32.match rcl_w16 (w32l w) false with
+ [ pair wl' c' ⇒ match rcl_w16 (w32h w) c' with
+  [ pair wh' c'' ⇒ match c'' with
+   [ true ⇒ mk_word32 wh' (or_w16 (mk_word16 (mk_byte8 x0 x0) (mk_byte8 x0 x1)) wl')
+   | false ⇒ mk_word32 wh' wl' ]]].
+
+(* operatore rotazione sinistra n-volte *)
+let rec rol_w32_n (w:word32) (n:nat) on n ≝
+ match n with
+  [ O ⇒ w
+  | S n' ⇒ rol_w32_n (rol_w32 w) n' ].
+
+(* operatore not/complemento a 1 *)
+definition not_w32 ≝
+λw:word32.mk_word32 (not_w16 (w32h w)) (not_w16 (w32l w)).
+
+(* operatore somma con carry *)
+definition plus_w32 ≝
+λw1,w2:word32.λc:bool.
+ match plus_w16 (w32l w1) (w32l w2) c with
+  [ pair l c' ⇒ match plus_w16 (w32h w1) (w32h w2) c' with
+   [ pair h c'' ⇒ pair ?? (mk_word32 h l) c'' ]].
+
+(* operatore somma senza carry *)
+definition plus_w32nc ≝
+λw1,w2:word32.fst ?? (plus_w32 w1 w2 false).
+
+(* operatore carry della somma *)
+definition plus_w32c ≝
+λw1,w2:word32.snd ?? (plus_w32 w1 w2 false).
+
+(* operatore Most Significant Bit *)
+definition MSB_w32 ≝ λw:word32.eq_ex x8 (and_ex x8 (b8h (w16h (w32h w)))).
+
+(* word → naturali *)
+definition nat_of_word32 ≝ λw:word32. (256 * 256 * (w32h w)) + (nat_of_word16 (w32l w)).
+
+coercion nat_of_word32.
+
+(* naturali → word *)
+definition word32_of_nat ≝
+ λn.mk_word32 (word16_of_nat (n / (256*256))) (word16_of_nat n).
+
+(* operatore predecessore *)
+definition pred_w32 ≝
+λw:word32.match eq_w16 (w32l w) (mk_word16 (mk_byte8 x0 x0) (mk_byte8 x0 x0)) with
+ [ true ⇒ mk_word32 (pred_w16 (w32h w)) (pred_w16 (w32l w))
+ | false ⇒ mk_word32 (w32h w) (pred_w16 (w32l w)) ].
+
+(* operatore successore *)
+definition succ_w32 ≝
+λw:word32.match eq_w16 (w32l w) (mk_word16 (mk_byte8 xF xF) (mk_byte8 xF xF)) with
+ [ true ⇒ mk_word32 (succ_w16 (w32h w)) (succ_w16 (w32l w))
+ | false ⇒ mk_word32 (w32h w) (succ_w16 (w32l w)) ].
+
+(* operatore neg/complemento a 2 *)
+definition compl_w32 ≝
+λw:word32.match MSB_w32 w with
+ [ true ⇒ succ_w32 (not_w32 w)
+ | false ⇒ not_w32 (pred_w32 w) ].
+
+(* 
+   operatore moltiplicazione senza segno: b*b=[0x00000000,0xFFFE0001]
+   ... in pratica (〈a:b〉*〈c:d〉) = (a*c)<<16+(a*d)<<8+(b*c)<<8+(b*d)
+*)
+definition mul_w16 ≝
+λb1,b2:word16.match b1 with
+[ mk_word16 b1h b1l ⇒ match b2 with
+[ mk_word16 b2h b2l ⇒ match mul_b8 b1l b2l with
+[ mk_word16 t1_h t1_l ⇒ match mul_b8 b1h b2l with
+[ mk_word16 t2_h t2_l ⇒ match mul_b8 b2h b1l with
+[ mk_word16 t3_h t3_l ⇒ match mul_b8 b1h b2h with
+[ mk_word16 t4_h t4_l ⇒
+ plus_w32nc
+  (plus_w32nc
+   (plus_w32nc 〈〈t4_h:t4_l〉.〈〈x0,x0〉:〈x0,x0〉〉〉 〈〈〈x0,x0〉:t3_h〉.〈t3_l:〈x0,x0〉〉〉) 〈〈〈x0,x0〉:t2_h〉.〈t2_l:〈x0,x0〉〉〉)〈〈〈x0,x0〉:〈x0,x0〉〉.〈t1_h:t1_l〉〉
+]]]]]].
+
+(* divisione senza segno (secondo la logica delle ALU): (quoziente resto) overflow *)
+definition div_w16 ≝
+λw:word32.λb:word16.match eq_w16 b 〈〈x0,x0〉:〈x0,x0〉〉 with
+(* 
+   la combinazione n/0 e' illegale, segnala solo overflow senza dare risultato
+*)
+ [ true ⇒ tripleT ??? 〈〈xF,xF〉:〈xF,xF〉〉 (w32l w) true
+ | false ⇒ match eq_w32 w 〈〈〈x0,x0〉:〈x0,x0〉〉.〈〈x0,x0〉:〈x0,x0〉〉〉 with
+(* 0 diviso qualsiasi cosa diverso da 0 da' q=0 r=0 o=false *)
+  [ true ⇒ tripleT ??? 〈〈x0,x0〉:〈x0,x0〉〉 〈〈x0,x0〉:〈x0,x0〉〉 false
+(* 1) e' una divisione sensata che produrra' overflow/risultato *)
+(* 2) parametri: dividendo, divisore, moltiplicatore, quoziente, contatore *)
+(* 3) ad ogni ciclo il divisore e il moltiplicatore vengono scalati di 1 a dx *)
+(* 4) il moltiplicatore e' la quantita' aggiunta al quoziente se il divisore *)
+(*    puo' essere sottratto al dividendo *) 
+  | false ⇒ let rec aux (divd:word32) (divs:word32) (molt:word16) (q:word16) (c:nat) on c ≝
+  let w' ≝ plus_w32nc divd (compl_w32 divs) in
+   match c with
+   [ O ⇒ match le_w32 divs divd with
+    [ true ⇒ tripleT ??? (or_w16 molt q) (w32l w') (⊖ (eq_w16 (w32h w') 〈〈x0,x0〉:〈x0,x0〉〉))
+    | false ⇒ tripleT ??? q (w32l divd) (⊖ (eq_w16 (w32h divd) 〈〈x0,x0〉:〈x0,x0〉〉)) ]
+   | S c' ⇒ match le_w32 divs divd with
+    [ true ⇒ aux w' (ror_w32 divs) (ror_w16 molt) (or_w16 molt q) c'
+    | false ⇒ aux divd (ror_w32 divs) (ror_w16 molt) q c' ]]
+  in aux w (rol_w32_n 〈〈〈x0,x0〉:〈x0,x0〉〉.b〉 15) 〈〈x8,x0〉:〈x0,x0〉〉 〈〈x0,x0〉:〈x0,x0〉〉 15 ]].
+
+(* operatore x in [inf,sup] *)
+definition in_range ≝
+λx,inf,sup:word32.(le_w32 inf sup) ⊗ (ge_w32 x inf) ⊗ (le_w32 x sup).
+
+(* iteratore sulle word *)
+definition forall_word32 ≝
+ λP.
+  forall_word16 (λbh.
+  forall_word16 (λbl.
+   P (mk_word32 bh bl ))).
diff --git a/helm/software/matita/contribs/assembly/string/ascii_min.ma b/helm/software/matita/contribs/assembly/string/ascii_min.ma
new file mode 100755
index 000000000..8871397c8
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/string/ascii_min.ma
@@ -0,0 +1,177 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "freescale/byte8.ma".
+
+(* ************************** *)
+(* DEFINIZIONE ASCII MINIMALE *)
+(* ************************** *)
+
+inductive ascii_min : Type ≝
+(* numeri *)  
+  ch_0: ascii_min
+| ch_1: ascii_min
+| ch_2: ascii_min
+| ch_3: ascii_min
+| ch_4: ascii_min
+| ch_5: ascii_min
+| ch_6: ascii_min
+| ch_7: ascii_min
+| ch_8: ascii_min
+| ch_9: ascii_min
+
+(* simboli *)
+| ch__: ascii_min
+
+(* maiuscole *)
+| ch_A: ascii_min
+| ch_B: ascii_min
+| ch_C: ascii_min
+| ch_D: ascii_min
+| ch_E: ascii_min
+| ch_F: ascii_min
+| ch_G: ascii_min
+| ch_H: ascii_min
+| ch_I: ascii_min
+| ch_J: ascii_min
+| ch_K: ascii_min
+| ch_L: ascii_min
+| ch_M: ascii_min
+| ch_N: ascii_min
+| ch_O: ascii_min
+| ch_P: ascii_min
+| ch_Q: ascii_min
+| ch_R: ascii_min
+| ch_S: ascii_min
+| ch_T: ascii_min
+| ch_U: ascii_min
+| ch_V: ascii_min
+| ch_W: ascii_min
+| ch_X: ascii_min
+| ch_Y: ascii_min
+| ch_Z: ascii_min
+
+(* minuscole *)
+| ch_a: ascii_min
+| ch_b: ascii_min
+| ch_c: ascii_min
+| ch_d: ascii_min
+| ch_e: ascii_min
+| ch_f: ascii_min
+| ch_g: ascii_min
+| ch_h: ascii_min
+| ch_i: ascii_min
+| ch_j: ascii_min
+| ch_k: ascii_min
+| ch_l: ascii_min
+| ch_m: ascii_min
+| ch_n: ascii_min
+| ch_o: ascii_min
+| ch_p: ascii_min
+| ch_q: ascii_min
+| ch_r: ascii_min
+| ch_s: ascii_min
+| ch_t: ascii_min
+| ch_u: ascii_min
+| ch_v: ascii_min
+| ch_w: ascii_min
+| ch_x: ascii_min
+| ch_y: ascii_min
+| ch_z: ascii_min.
+
+(* ascii_min → byte8 *)
+definition magic_of_ascii_min ≝
+λc:ascii_min.match c with
+(* numeri *)  
+[ ch_0 ⇒ 〈x0,x0〉
+| ch_1 ⇒ 〈x0,x1〉
+| ch_2 ⇒ 〈x0,x2〉
+| ch_3 ⇒ 〈x0,x3〉
+| ch_4 ⇒ 〈x0,x4〉
+| ch_5 ⇒ 〈x0,x5〉
+| ch_6 ⇒ 〈x0,x6〉
+| ch_7 ⇒ 〈x0,x7〉
+| ch_8 ⇒ 〈x0,x8〉
+| ch_9 ⇒ 〈x0,x9〉
+
+(* simboli *)
+| ch__ ⇒ 〈x0,xA〉
+
+(* maiuscole *)
+| ch_A ⇒ 〈x0,xB〉
+| ch_B ⇒ 〈x0,xC〉
+| ch_C ⇒ 〈x0,xD〉
+| ch_D ⇒ 〈x0,xE〉
+| ch_E ⇒ 〈x0,xF〉
+| ch_F ⇒ 〈x1,x0〉
+| ch_G ⇒ 〈x1,x1〉
+| ch_H ⇒ 〈x1,x2〉
+| ch_I ⇒ 〈x1,x3〉
+| ch_J ⇒ 〈x1,x4〉
+| ch_K ⇒ 〈x1,x5〉
+| ch_L ⇒ 〈x1,x6〉
+| ch_M ⇒ 〈x1,x7〉
+| ch_N ⇒ 〈x1,x8〉
+| ch_O ⇒ 〈x1,x9〉
+| ch_P ⇒ 〈x1,xA〉
+| ch_Q ⇒ 〈x1,xB〉
+| ch_R ⇒ 〈x1,xC〉
+| ch_S ⇒ 〈x1,xD〉
+| ch_T ⇒ 〈x1,xE〉
+| ch_U ⇒ 〈x1,xF〉
+| ch_V ⇒ 〈x2,x0〉
+| ch_W ⇒ 〈x2,x1〉
+| ch_X ⇒ 〈x2,x2〉
+| ch_Y ⇒ 〈x2,x3〉
+| ch_Z ⇒ 〈x2,x4〉
+
+(* minuscole *)
+| ch_a ⇒ 〈x2,x5〉
+| ch_b ⇒ 〈x2,x6〉
+| ch_c ⇒ 〈x2,x7〉
+| ch_d ⇒ 〈x2,x8〉
+| ch_e ⇒ 〈x2,x9〉
+| ch_f ⇒ 〈x2,xA〉
+| ch_g ⇒ 〈x2,xB〉
+| ch_h ⇒ 〈x2,xC〉
+| ch_i ⇒ 〈x2,xD〉
+| ch_j ⇒ 〈x2,xE〉
+| ch_k ⇒ 〈x2,xF〉
+| ch_l ⇒ 〈x3,x0〉
+| ch_m ⇒ 〈x3,x1〉
+| ch_n ⇒ 〈x3,x2〉
+| ch_o ⇒ 〈x3,x3〉
+| ch_p ⇒ 〈x3,x4〉
+| ch_q ⇒ 〈x3,x5〉
+| ch_r ⇒ 〈x3,x6〉
+| ch_s ⇒ 〈x3,x7〉
+| ch_t ⇒ 〈x3,x8〉
+| ch_u ⇒ 〈x3,x9〉
+| ch_v ⇒ 〈x3,xA〉
+| ch_w ⇒ 〈x3,xB〉
+| ch_x ⇒ 〈x3,xC〉
+| ch_y ⇒ 〈x3,xD〉
+| ch_z ⇒ 〈x3,xE〉
+].
+
+(* confronto fra ascii_min *)
+definition eqAsciiMin ≝
+λc,c':ascii_min.(eq_b8 (magic_of_ascii_min c) (magic_of_ascii_min c')).
diff --git a/helm/software/matita/contribs/assembly/string/string.ma b/helm/software/matita/contribs/assembly/string/string.ma
new file mode 100755
index 000000000..0a81fb6e6
--- /dev/null
+++ b/helm/software/matita/contribs/assembly/string/string.ma
@@ -0,0 +1,56 @@
+(**************************************************************************)
+(*       ___                                                              *)
+(*      ||M||                                                             *)
+(*      ||A||       A project by Andrea Asperti                           *)
+(*      ||T||                                                             *)
+(*      ||I||       Developers:                                           *)
+(*      ||T||         The HELM team.                                      *)
+(*      ||A||         http://helm.cs.unibo.it                             *)
+(*      \   /                                                             *)
+(*       \ /        This file is distributed under the terms of the       *)
+(*        v         GNU General Public License Version 2                  *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* ********************************************************************** *)
+(*                                                                        *)
+(* Sviluppato da:                                                         *)
+(*   Cosimo Oliboni, oliboni@cs.unibo.it                                  *)
+(*                                                                        *)
+(* ********************************************************************** *)
+
+include "string/ascii_min.ma".
+include "compiler/utility.ma".
+
+(* ************************ *)
+(* MANIPOLAZIONE DI STRINGA *)
+(* ************************ *)
+
+(* tipo pubblico *)
+definition aux_str_type ≝ list ascii_min.
+
+(* empty string *)
+definition empty_str ≝ nil ascii_min.
+
+(* is empty ? *)
+definition isNull_str ≝
+λstr:aux_str_type.match str with
+ [ nil ⇒ true | cons _ _ ⇒ false ].
+
+(* strcmp *)
+let rec strCmp_str (str,str':aux_str_type) ≝
+ match str with
+  [ nil ⇒ match str' with
+   [ nil ⇒ true | cons _ _ ⇒ false ]
+  | cons h t ⇒ match str' with
+   [ nil ⇒ false
+   | cons h' t' ⇒ match eqAsciiMin h h' with
+    [ true ⇒ strCmp_str t t' | false ⇒ false ]
+  ]].
+
+(* strcat *)
+definition strCat_str ≝
+λstr,str':aux_str_type.str@str'.
+
+(* strlen *)
+definition strLen_str ≝ λstr:aux_str_type.len_list ? str.
-- 
2.39.2