From 21f1fb39b5e1187ef87387f20522e60abe4f7c19 Mon Sep 17 00:00:00 2001 From: Claudio Sacerdoti Coen 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 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 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