From 39e5e8f70c5accdc02bb2dbb4015556f09e39737 Mon Sep 17 00:00:00 2001 From: Sergio Date: Tue, 27 Jan 2026 17:35:30 +0100 Subject: [PATCH] Au, acabat --- ... of Fire III (USA).srm.2023-04-15_08-18-27 | Bin 0 -> 131072 bytes Breath of Fire III (USA).srm.80 | Bin 0 -> 131072 bytes Breath of Fire III (USA).srm.armario_abierto | Bin 0 -> 131072 bytes ...th of Fire III (USA).srm.armario_revertido | Bin 0 -> 131072 bytes ...h of Fire III (USA).srm.armarios_extendido | Bin 0 -> 131072 bytes Breath of Fire III (USA).srm.original | Bin 0 -> 131072 bytes Breath of Fire III (USA).srm.solo_moverse | Bin 0 -> 131072 bytes ... III (USA).srm.todos_los_armarios_abiertos | Bin 0 -> 131072 bytes abrir_armarios.py | 52 + abrir_armarios_extendido.py | 52 + detect_armarios.py | 85 + detect_bitfields.py | 0 diff3.py | 23 + diff_saves.py | 25 + info.txt | 149 + revert_2934.py | 38 + revert_armario.py | 38 + revertido.srm | Bin 0 -> 131072 bytes saves/bof3_saves.csv | 7486 -- saves/bof3_saves.txt | 58422 ---------------- set_contador_armarios.py | 43 + 21 files changed, 505 insertions(+), 65908 deletions(-) create mode 100644 Breath of Fire III (USA).srm.2023-04-15_08-18-27 create mode 100644 Breath of Fire III (USA).srm.80 create mode 100644 Breath of Fire III (USA).srm.armario_abierto create mode 100644 Breath of Fire III (USA).srm.armario_revertido create mode 100644 Breath of Fire III (USA).srm.armarios_extendido create mode 100644 Breath of Fire III (USA).srm.original create mode 100644 Breath of Fire III (USA).srm.solo_moverse create mode 100644 Breath of Fire III (USA).srm.todos_los_armarios_abiertos create mode 100644 abrir_armarios.py create mode 100644 abrir_armarios_extendido.py create mode 100644 detect_armarios.py create mode 100644 detect_bitfields.py create mode 100644 diff3.py create mode 100644 diff_saves.py create mode 100644 info.txt create mode 100644 revert_2934.py create mode 100644 revert_armario.py create mode 100644 revertido.srm delete mode 100644 saves/bof3_saves.csv delete mode 100644 saves/bof3_saves.txt create mode 100644 set_contador_armarios.py diff --git a/Breath of Fire III (USA).srm.2023-04-15_08-18-27 b/Breath of Fire III (USA).srm.2023-04-15_08-18-27 new file mode 100644 index 0000000000000000000000000000000000000000..d030e3d3cd1be6ecc14878a0d126216ebe9995a5 GIT binary patch literal 131072 zcmeI*d2AH-6$kJ)v-jG@8(&-oyx7>7B*n2)j0ve@n;6WEjm_1P8dw_>7rPW}6QZ(g zAYNBOaRMq>X$VqFTcJj(dMHgvLfWc-L`{__sgy=Nh?J-ZrGZpMN?H<6-<#R-v0m@4 zjai5E`xCproq03!`^{$#+xzyntf`{OEK@c}>p4W4R#{QEy1wr2qN00?i!0YvmlPEx zpkwYR?cbAt_LHKtUz~vUoo7RhXj%eV8`;EJv~Qrmf8@!LfH^q-LdZD(5^%PSY+};S zKaGoYYm$yXw~O}SkMj@L-^iO|BIe-!gZnS;zqtSYzutcnagRkC5P$##AOHafKmY;| zfB*y_K(uC(^Y3+4=}Mq6@KoSf;7H(PAb8|~z!QPT`Pmofk-7Y;_DD-${gFNLDzGsS z}as7ySJ~VswWsc-FK$!#54B>U01H>op`3?wCkO|^0_DaUhTW|!VOJ(@efz8 zy>Q{`%NPFoH|^C67cP8owV&JcbF}qPN zKX<_8=l0KS?Fa_@dOEs;yC0|Cnib3R_Ro}@ci+r|5R%GuS--Dv7?N=F*b?UDWOJa^s~^!N3(GPoos#{3zwG3hqtbrv$!GNTbBj+tYwZ8Uk^7%Sslm_MEu&sRrZtM=dlBFAjY!avG#?j;M-lG5L#wR*3leu;ifvq(M~p*U17 zHhz>Q+nl?2j>M1CLzHjCB|I!%y=wXDZ`G{eC2Q*%_*u#+qvGez^97cS2W8Tw_Nxkg zHV_Gav9@JzBRQukZ|VDzzj%I{N8L(~iKIj7J>;h}+RlB}yI`@aHfu3ilBJIlpGOPG z%W(?DWgpD=y0vC&TefZvz1+3EvH2n24xV!V;M~t&*XMdj>5p`*%(a&{?%PLdmhxbY z%vrD~-;+!)l82IbC8-b76J)1p980pQEGd0h>T&XZkiJ|qAL}$TZaR9LR*6R{PjCCG zaUxObjK0tUnWXUBYN6Q?R@&(EwYOPZbi^V-wIr7pT|~KZtTn0gXf8Qfio2{s>Q2cv z`$IfO;6K~Hx(8u|_Gpl%x#H(o`TMm!U=Dn8Fo3EKrKb9`5-Slwl#(L71 zG-m$rxj%=Z=~};{U!a4+PiW}@3S8qdtk@Fy z0JCK0xZE~Xak(oLw>IoSZp|y7p@_F!D_2N!C>ICs>}DI0Yvb<$)h3;hd${p;fw62A zn*JzP(|6Sl_bu;e&N8tsMvJ+FN$|)->*G*;~=tzPmAO zxvmb|KAYG|JQQ#2 z`Ts9U{@)$S&vp#__0Dgggq0l|0n-O=DJG@JmLBO z@6pW9MgBiaDVGEfasEHaqt?^6_58ooE##vN+QNw`$yBPt^8XUgqeAj>JYxP|HmR41 z$^XB%TsBraBLDvx=l{vf?<4=Oi${98ee(ZVbiGRUfb;(zRq@d}J^wHD)6`1oByT5< z%>PTgg6^j5uy}m=|3NY2|8Lj)KYuEMJ}Qqdi#~X~M|)-F{|jT}|F<@Ww%~9$`2!!$ z@ch3-W99#gta|=`w5|-B@10+kIyC=pq*~(0{}0*9VE%u0#Qgtv$g3=TjPJI*@rJt< z{^SqQkN9Eax9{Rt_sdVvc=G>4v;Um=nAj4Y{$DV$n~%A*;^Y!goA~^Hyyu+p_kdHC{J-48jlTsa4 zW#l_^JO-EFK`ZBQin-9Z>w@diS2f=6n`!y!L0L}n|7q#Z^9W_>mDJ~{m!|W0Wga1- zC)Z_6_^QzOe~CZB)Au%`ndMc_XEfljWSC9KNO8`{C}qMPNl5C#9IM(L) z|HS71T}rj_7JLa0+vCynd2(G_rOu`$Y$_v>2d?XZ@&87=fLDne=ar%qjQ<~P{Qqlj zylrOTnLP^O7(#>je_6@Ow~YVq|1d)j#m@i7pFNy; zr(*`^|Bq{(pYr(s)UV6+%hz-4@&EdA#?xT_Kb!nR=9@2%Oa7n7>PsGE-k*rCe4=Cg zFjCy|{W*8>XKj>${Qr#57XZvr=TEP!=F$Gfw*buLuL0Pse-A+Z)SO%Kp8)ab{~E`V zNgMu8#ok=W{U=RHcI)4^VEQGhp5}HrZyKS8DTn0LDE2KZVEtD|9hlapUiS zB%6GFjoibHzYC0RMauu19YzfS2tXi~K)mmhVL1pu00Izz00bZa0SG_<0uX=z1Rwwb z2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$## zAOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;| zfB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U< z00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa z0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV= z5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf zKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ z009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZafiH%@ F{{Y0`Q$hd$ literal 0 HcmV?d00001 diff --git a/Breath of Fire III (USA).srm.80 b/Breath of Fire III (USA).srm.80 new file mode 100644 index 0000000000000000000000000000000000000000..59e73601fb4ea1e7920c3a37dfb2494c8fdc7246 GIT binary patch literal 131072 zcmeI*d2AHd9S88=%+8)Rcw>yY40vs0W0DldP5~2A$43n2#>VDqNe!%xiHltdwh2*K zHW05Pp*R5*tTY6vrL9mSRXtRtBq43pKcc2elvGNi9z;r1gwjB&A|)+}r@!CKj=iky z-L)}GNWV|)zMXk9@4flV;obesTUJ%ltxOZwN$c4}x?WLUx3a$O?xLc5i;FAPRF@PL zC81-U813Jag!WTnv|pTr_FbpLjp%w3S{vHLX|!*mz<=n$k%T!o{=&#O{*rLC4Q=9< zAAdS0>DDdU|J*Lxhd+)#oPR?vj>(vV>kqEKxc=h$`~Q0VO~y4AZ9o755P$##AOHaf zKmY;|fB?~|TO5C{tDK|+8-vdTj|2||j|W4C9tb`ae1f0-!5*2*uWApq1lJzgC9i_( zgCTxi7d*;S4+p<{sEVi7#NLmuYG&c z6e8k(6zB|5$VJrK)e-7E=_cA=?{DZh83;8u)HgMCg#uko4fUHlWQ7f9>pMb$p3YDx z)D)uLzN*8auI}Exn#!I~=w#oi(qqrv8**Q|ns@BEl9TRt`^s{T^}W`2;l*pZ{?Z>V zUwQG|6xX=gyt`@Nz%58Q^BAr#lqr=Dc@jxc#06f0O@2psTs5-rw{@DAd)| zRDWilJHYLq+1wEd_4Raghju*_x4$N* zGDiD7A+!Bn-b87i`kKw{@9pC4KH=(W=591~xTGTuXLiZ_f^&Gs9CId+FN!`-q&gZ1evp%Xt>hOHY~f7OmzE5J~euKZ5TGG4N_u7RH=oiH~1926y2Z;CO1_H%lulc@&qfz)4%My|lPy*HDCKi#9{ISO z!sW6JR{5IMR%@F!Zw$ZOv9+=JA^$d>^8Db;&)+cSdP(V*-7->I+PG&AshP@yHL}FK z1^M1odWpQ0!YfIBke(t3P35u_O=U^x!xFEHw}Xu3nt5NRTjiFc*QH7MaOv4CUk@Kh zY18|{3rr@3zgCMrz6RG`@AtR2+1zx40Zdf0FRo=Mmf$++*mvx%OH~jqRdoKI%Ws^&_>W^{ zpFGob@iG0Q&-mIyw8&*#7>os7hrL=aA1m3$R6w59_B@x$ms)Npe#*@*(tQ2bp3*z@ zPtqVU4MPe<@^3luUa!B z@(^VyMUN77aJRo-qmaBY`Y}IJjb-NZ^S!iz&q-1WZ4*3>(gIgnWz~{J>fDOz2kp*= z`%|V)&P>nnEt@zc+nqao_OzKBvT`=&7th+X%BW!6o@#5Vmo9Vq9NDFX+U!L()!G%~ z)$vqT_rYmI%=}zVR;FaBKWBA z5*061^1E8|9oj~&yow)^%R{cmzo6|(_(E)~EW2FF#w#iOUg1XSQ}}pT6r(>@`9L0S zPp04I>x1MkjNv+A_1mgNm>c>^Ch=c|zM)=ik#d zx;I3XZEXqNL9n8+)xSHc4{KX?KfJ%LrL|*!U3<%R|Ek74ExXHG+jllbEf+Oe-rnBo zU%#)lr9G-(xJj;g?<2z%81ptXw(iht{oDNdrj~YHuiM_ZS6|!IxKB4q%iEj$t*iEY zZJjweVlB62L88|!EC&GyKmY;|fB*y_009U<;C2^CF#f+T9RIK7_j}!IAL|TU6mFCl3r0p^L1-ivOqnM&^1J7I>rM|KFn-Ux@gB zrc!pF^pWHLDPFan9y8+qlDCkbGH4SArX*6SUKjtD@;oXeAD0gs|CcI_G(PeF_m@g# zwL{|npL6`5toT0S|AzQ*Pq$C}Ka;Lj$`)|^->WKqjz04D_%_L(rB<3m@^#|S_`j5w z)7_L6Ri0SX|K{d!4Nj+vZ}@OU$N!}? zUi`mEGvfavb>+JGzPY7ok@0^s)RI8_Kcbew`2Vb7G5zg)x3&jsebA1?kc*L8`b z=kY^wxfaXgXA=MC)80x7UzB6T+pXmi&80qxPmeXli@#gtR&KQ;(^mX^O!5D)Lv+1X z{fXwX{%G2d7yplLSL(kJ-{|^cPT#8dztO2LNc?{g$cXoO*M zMR@$blt04bne(E`t=|VQ$Nx*c<1zlhdip%rG{@|2at?7J6OAcxx%&#v`)t7+OB6@&6OzjJLjh#{Xw3B@c+Bdr>~0D39_H#wUc4 z@1;HbdlbWu|Ci-f(?Uwl`2S4h+s6GU%lTdpH6=3s|1|C3@zjmnV;OR4?rUrOe{$ph zZl&7%3ciGg?eS>(JUOp5$+KuNo61P!f%AG`{J&XVz^e>j&MU=882>-g`2W}6e8-By zGkXleQ4|fv|79hO$NvwXR>uGyXcG{^t{TgLzQf0SVq#gG3d9zC3Kr*k^T z|BvdOpYizrv~SA!%ja|a@&Cqh=F?#OKZ^np^R1UhCH~K2^(786=TF3EKG6|=m?3WY z{hYh_UK?c~{y#nZ0|2wtxzj4Dd9=UzD*!qCGXNWn-vP*>A6>YI{kR~$CGV*CJr!qI*XNlUz+ zgW?{Ae+EF4=)Y6O{@;WS$*6yB&}dWIy$Maktdd*ik^i!V$!}XaW^A~_;pFK5giM=6 z|C38##Q$Ro-P%HP{J#-$w>o0CdvsOC`jf-slid0pfKiYCpTOh)6*`}&xcPY?#V$Wz zBiC^AbAj2d;o|>Rhmk`70uYENkm&bhSPlXZfB*y_009U<00Izz00bZa0SG_<0uX=z z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV= z5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf zKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ z009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_< z0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb z2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$## zAOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;| zfB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U< z00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<;L9QKKaGJ= A=l}o! literal 0 HcmV?d00001 diff --git a/Breath of Fire III (USA).srm.armario_abierto b/Breath of Fire III (USA).srm.armario_abierto new file mode 100644 index 0000000000000000000000000000000000000000..accd2817c4596ebc20ce748da719f02a385b3b6c GIT binary patch literal 131072 zcmeI*eNYtl83*uZ_udbb3j(5|a)KZxsRU9LH6?&S@eKt5Us_Yt12I&nRlu03=S9QO z87CwXn3-hiIB7JUI+L^}Y@cWM7S7|i zI}wkVet+ZL?{=Tv{r&c{FTg$bJJ(jxM3%`Lr1e}PO{=V^U(-;3Z*lScB_)-$)uqM7 zN$8k6M*H_Aq5YH??Uy8>edn1_Bbt_k)_{Bw-HDzYsFcza*S(Bb%7; z^H1X<-I}1|&+Vdp_~ZP;^*8e7n2b5N|KR?M`!DXl|F8GoWZYxX1_U4g0SG_<0uX=z z1Rwwb2oSBE;QV`i)f6Sr9C$i#G;la@A`m?MVBpEX6a4H8^vPU)Rd={8u>SCFc@@|g z2=a4X;22Lm68P@n<@~xf_Hlf9>x-3d-&c2E>WacGM;qQ-)0=bf;I-6_>=WDG-0Y%Y zkcj`0zdJ}lCsBV-SFrn(i|9auud(ZtKiJyX(9+Tq^!KzhHf-sV6`Ia9bOrr=-N9h6 zB}n}P%Z~(mdiw`zs``S#Qv;{Vjz4>U&~^D*{_$r^Pr2S1D4%nD;MIYPFI?BO7yoeO z>I>(uynOzzf74z)fByUjR|dIFKQ~K#y+MC3*ZsRf?e{hMT6`z{J*_PbzLqC~!Jd|u zhO_%!es2HlmabrMps%Ypxa$e(uUWZVZ~t`Z3GTqa>C;u0S3Z8~^0l(ccWO>>`?Yhb zVzl2EG}`ayU6l4|pw-y_{vO`%lg^%2?nXZI)d`(-CiACdO+PCTo(pI36?Ib;7XjNJbeQl(X@)}Q4`8G2>DSS~aD zGkNlBLP#h{3 z8$TAM+MGLij>M1A!&G3zC457?di9Dm->O;3OV-sl^0SnaM#azF=L#(u56PrU9aI(i zY$y`>VqM#wW^ztd-qQD_VDY?kkGh2(7fFZIyU9=Kw2k|$cfn#;ZPpU9q)HzpK9}Z` zm*W(Q%RZR#+I41Yo40HVz1+F2x%FY+cAj$o;Ox&|*XMdj8H{$U%(YiE@7+skmhw=I z%$dKiz>`WZl7~`wC8-b5lVqoCj-^;tmXtm$^Ei1wNMEj%k9E2kHyu4rtHh&~XSROT zIFTrA`ao!bOj7u5wb1M+D{b`oIy)>bI&6`kTAIg;E~Gp;)|%A$G>4ol#a-4Rb*EID z{b8OX@mbuzv{B-+#mKUCTWjR3xYKpMHXk3(v?@L^c@EImumb!<^_;`Mqrz}H# zTy3{alVdIMI*u2O66ZxiWmD6}(5s5(?GJ`t4pkX(&d0SK-{>IQROOfYxwC3vQM#(^ zrg}cUWRdy|9i*w$!rQYC^>H5W%xaz^@oHMYmN&*{@m|a6&DTt*AIp~4H9gY4v4Qj@ zjhR1u{?DQ46m3w^FVfI-WVPP6ql4^sDId(1$dZKxDdheMEt6HOQg7uxsw6>0PDeQ( zt$8IDzFvqVUP+C7E*NpyiSW2=(I~~G=Bwd)N&X9=373@=%V(os*G;>8?VWCOP5!CC zuejOV;Sw`ebU&r z>rZLgzkd7r?*}#QkVLdhBi?%Pxl0ahQO|Yl(5Hh_>642yjQN^&(4jB)pR0#1zVY^@ zkFRPD?JpmdcN^hbe*WZLTHy4r;%kDB>}7{Pn{vap`HJ4Q%=leSXtu+l+W6m<*DqZ9 z$MN!ypYFNzZSBKP`QAgc*s0$b^aY(qJl1|bS90|!zdWm*`A(H@wcJqrlINW^!#jBW zNv&J^IPK!0U3vN{uG}-8;dN&e5-sHmgJ^cTCp&LZfxNt1o{aL?(X@9p?X}v$rGKYa z%$Z?zkaCpb$B4SP+uyHI_^c)RF+WoEWft)B{nW(QBq>FfNp5>tp);*&`Lf08yvpi_ zY>vhUQnE9%(lfj(Cr{0FoJ|EKvo^2QH!yBbbv4y1Ryw@)+_EC;?8O$< zJQU;BK%5PglrHk-6%?l4Ww%+JlieQvnUvI$?Xp?ZCl`6==FFZqGyk64IbV`vlfg=@2T$+dfJIRit3*ft5jv($^A=^(sw%aVF>Ph+ zD{+h5G#BoL{M1Z#`$prLnHe6%k&$J~;OVjN%ox_RC{~Bf_*G&IYv2A=?0ORl{|aE1 zoLraNrYbIXh2qw3c#vE3%4aANEmzAG(j3Z#;XAw8M)cbFdqA~GXXGAk{9RxyTSd8i z`*#xmNK`yj#lO`WzoBj7jW6ei)bfz~@h@nH61oxVE6X95*mxC%e^ARdsYE^a+C1&F#KD5q((Sw&#%p^=<842kJZ9cKFsd?`_*t(cZbMIbykp z$%@X-cHhSR?QNYAfoPMw<$aGv3+VHjn%j43b-wLBZF5_vrq%Cg-lwf^Y2L5t(TdI% zU;EmQF3Foy*&t`-rOCpv@bn;-73|;uTX8u3*H!|0~sL&Ic|NkD% z_*~@wvy}3s(nrq!r+Cx``nI0`m%5F7ltG(0F(sKw^@jYv#Pg|$yd003|CdebWqk7g z@2!xH)s4vif5!QLGV}Y$|Lfw>p6;Cde->S z60e|pDJLSHSpI)l4Eg^%HUH0_ilC3m6U(9xAMep#nfd>sIQjoAt)VSA98Uhghchz& zFVT4U|6;42{~xU@H_Z3WD@zN{{~M{61oHo3TQT$hSC-C-n*aX}d6fl^^WBy=-gvLV zpZp>E5kHLl_C5US0m)HWtnu^z;n{!Ae2j02O#jax-_6I}T1jfDH;)SR?7w`*CfP;u z|8(OA0E&~@hw18^DEWU&c>bTW|D2#Vvi~E0A-l!SMyCJAy@5FW?v(t$kxrJ6^^Jf2Khbl}_~Lm( zkCVX{h{J+E>AY$St)dHg>Y>BAzAQy*_F@$Eb!`>v7kn;QQ=Db9H7J7@fVmQwnlIJy=W@P+ai zpJ9AK==DC@%il*4ef+;Hw~iK3a>oB>Dc{sTkFttC>!GHE=l`FgojjhpnR_flPK{%2 zj{i??{@gITEeC>5_#yl9vc5|#0zJ3 z_Qu<07M|H-5Z**+IR7szS$X__^s-t8$4hZItTwC7@lRv?|G#DY|KNuidMJMWKk@A0 zjJqAvIsbo5>;9C-|EGOju3x^MmouJ*^Zz;I51VhkJSO>n9;+{Tkhy;%zVeBV z^211R%lGHp!=JTLhVuW@Ltg+eTb(zpvYJQx8{Yyjhrb43lm0yb1ygfx$A1FEqyK9h zOD1giKb3g%B=?^(In}Ly+k)wrtUBB6nrsUn{$D(t7fePU(pB%&RGVVA*cAN>02I#l zb4ptB{hSncEBrM8R>}T5WbFTK=#Y&1=LYpQrQO@mM9fWc%RKU5_AvQvOULvbx7!_@ z{hyR&k?enR3H1DbOrePl8sq=ucm5Zv0(fbSql^-|R4I2tWV=@dOfmpA5@E00Izz00bZa0SG_<0uX=z1Rwwb z2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$## zAOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;| zfB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U< z00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa z0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV= z5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf zKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ z009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SJ6C G1pWsM_)>EK literal 0 HcmV?d00001 diff --git a/Breath of Fire III (USA).srm.armario_revertido b/Breath of Fire III (USA).srm.armario_revertido new file mode 100644 index 0000000000000000000000000000000000000000..8965cb4c46f1b1be663cc0f8738e3626227799b3 GIT binary patch literal 131072 zcmeI*d2AH-6$kJ)v-jG@8{3%6fY&xQCP{JZ6fhxme8gZbgN@DAk{VbW6BoM_Y!jle zY#?4oLUDpsu+k8umbOBTRP|7ml7zHX|A?9@QBo<5dJrj55lRE8ij=e@p1wD;<72(v zU5r^m`u&OB-_E?5`TgcIhwXj)Th>(4tt?a4OY7N0npRO>zq+CR?xLc5i;F92t4oTC z63{Vsl=kmQK>JBi+AmH(`_9v$Ml>w}t&MHsG}<>%;6L`{NWdJNe<5U?e+f9-#x`-w z&p(Zebn6x!e{L7;!yo4#uD`K2$3)D*{Rj77+<$TZ{eQjxCgL88HXr~22tWV=5P$## zAOHafK!9k?EzZB!SEeh0roc0Sqk+SL{y^~X1A(UkPw=xZ&?|HKRo&s%z`Db`kfnz-NaNxU#tN3+o^yB!-)|V>Yxu@=)8gib_IjM z<{O+_w)_aRQ3jgCkIZI9)IrMpzG4ryyMT6oOHcAP?mFi;I)AZFJ9BMm;P}1 z%8TbNzjE%cf74z&ckbMWmj}5`KQ~LgJwbmD*L}M}?e{kNntdny-7U=xzUC)_!S3ef zhBNzJes2HFmd;>sptrLpxa$e(t65Q{w|}anpF1#c>Qv>W6_201bhWhN-I{)Gzc!~b zO8dP*qy0YKMQNV~T8#bg>*oDF;p}eVZZvl~r6Y}JcFX>EojL0Z`UeJDn|pTk(7@`F zBf&1-{|`zlPssj%P}+a$h_s*E|D4`_ZgKzf#{QolyZ=d~N~=_@Kg*Lc^vZluB{TiA zdGZ_NaN5k-6ROLG8;ZDo-GTi?jyaZvf0VF$>4LPR^tWiO-YcnJreD)+l8;6x4wZ|I zAB&T1&Ye6*;>YMA$~WQ?9u==%wS4t=YF6-)b@h$>Eaikz@pISN0!zk&GU-wWRfRqu ziiE#d+q$QToYR!I^?k`-GC$3uZlT9T(joP3@>3dZ<38(Mu-H|bwU{i)(npEUqXp#U zIECV}4`#e}t=ZbO=Gt*=ah*lB_CAN*|VaoV*{TFW17yI?armjvl8~;*rX;Tfc6c zNR&ErAhf_#QuuAP(Ci2+ZSeUz+AS_RY>}W^lFN%OqFg!Fn$&reLr#|BF6)rGQ?kwe z5YLhL9PVH0IC0rxc-gwGC45%Q={jF4k(G~ixh%@}B`!z!43jQP-A$!@Jip3QmZ3hb zvfF0Jv6grp#|y`a^CF?LY2${_tMaDp4}@M0RT(kP$2INWYA4$?<(K-ovvN^knyT!k zdOp5nk@_?pq-oU5+p`b#aX#WmR<>A8y;wK>Cu# z%pbn+=TJ0V8&vd*G&CJvt@G_@C;J`BhjS&ebWwg1xqm{-WEHE_Te*)aNl=l~QO-we zZn1^07b1yQP$QoUMqGAcWL&mrl%f*z)o{Hu@5RuB%Swvn^YO3ijk|np9d2_?{;9yP zyZ8*_qDj4<P@8Gqk zv@Y$F)C-4pm zO57qh&4qg*KQ$BGzR~#9sTm%{k&$W3;OU9)%mmi7C{~Bf_*G&8Yv24;?0ORl{|aE1 ztZbLtrYbIXx#HGFJ;<$j__TBOcfO z)%*6gU*9i8mF?|ueS%|C&9`BHTWd#HAkrjndEXH~1I^TAmwz;)K)9QCL?bFsZH|^K-Xn9Ao zuWilVudO#G$KA?p8Ho43h2Zts`#Pg_-yd001|CdebWpeWW z?=P2))s4yjf6n=TGV}Y$|LfwBo^GG~eyelob|_FaJL*hW!8Sn*ZldMbO7(@nzA6kN0@5%=~|0jQszWme3X)4kv%$!x^6c zmuRf~f00$s|Bu&|QS-g?OH)VY|BX~j9QpqdTN%#(&xx4-f0De)!pHe;%NuXJTj5Xs z5dDZBMt=J)es#a(s4Ujl`TvpGf6jbNZV6BSFPPlT$J|PwRvA>YrU}wYA|C8Q8jQ(-vpL703_CLzU17mDu z;$g}EbAoYdMuts30ANk@2LNuD{J)V-mXGyKe*Qn+bI$mCz^O|9U+&??-v!38kCgwH z`?}=O^Y|gP+>7P$Gs*w+Wp5URZ_3f~?dEdv*0MdxPfxVO%Dh!J3|LdLlg5>{)f%N?U@Z^{4)$RWN9r_Oe z2tWV=5P$##AOHafKpMni1GhlOJBnfa)~GGkCl*j}Xz5 z>oO*MRcQRb#2?}D%z0sP^ZNme@&B^j$r%6dQC?1$ZFv_Ja{j-9M|Sete-5e3XdUPO z@8_7_#ZmcxiOb0KtPyd2TzlyI0c49t87KcAipDqof2#6sg{;8i|J@3|2bv=*!Xpg|4)fA-um_#|DUOpJRpv)CHZ`zJj!Pn zUl4k|kM{ESQA8g9FUzf^#gv%w|C!3S_0OZM`@4>BQ%`6fT_y4y9yHgfoX(QsZc5q(Hgz0;Cyirr#U^e+HVINQ%D zY039D^u|JPIQW=Cu`x2DQif3my1Qk&lcaNXnoQ+WKpLg(WZH~t<- zvdP!i$UWTnyTIsHr2N0xVblh)I3 zb%`mhW=gtRlg({0YqIPmOJ`fVE&HQcmp1K^uGtoww3#towaZM}&6cz0IWKU%z`cNY zt?v7a_nw#MoZs(vKIhy6+~@wTD=X<%mho$)^&BEyuPCowQCE9UQPF+H#TBcoN{Wh- z&@o?}_U}zX`zdkSFHS=Hp3_z%x}JpA1~zdT?VBj@A9!&jVGXW73mMm660Wv^P2BS9 zPv;`tx<%)o+eQ2E$MuKT-@uz=GS=Y!gZnS;zqtSYzute7agRkC5P$##AOHafKmY;| zfB*y_K(z7}=ih59Cn({D@U!8=;e+Ah;mE-U!%v5w;^$!ah^*zgnuE>ZH3xUfTzFkL z!q02NM|tVd@b?Zb=B3r~&*Q6`U#@uf-kN(;mlSL|T=&6>uI&B$uco$6I=)TI;B2D#mjg6g=P-kO(-KKWgVg1><_DJYRM|GI-45nf{jl_BAtzm zb!YZ^L)`wEP3@6L&yn`7$d0F|yL#zjqy1AQ$GHPNr%qK~TKeS4OIJ%P-m5;&?XR9$ z8K?at5wrbnK16AsdYa7R@9yN|KH=$X;%+pyd!!@vXLic*cbqvJjD&i6nj5=zbWzWW zl0%UWKK>6&D^JMre^`3_)FEj<_xSTh`?ycbqM7WIQB`UbRT@B=!sJv4pk^BX-)BWludQv3aGTlibN~bN{XQK-am+I7t$&o63l=v)~LjjJH z6_;bMX(Ik$gXevue9~SvNd>mwK*Tm;K-HzLievc;c!OC-+zhPZS zX;XTv4KhjLx7A{=ul~K)1%qv^4lf;a$U3zomp7e9xpGvxO!H_ad02|OY(N@LsZQ4; zyhh^FxqoRx#HGgAvUy8W?5c#zHNj>gjn8$tY|8f~E{FIElP=4&lS=t~evOwLeSKW+ za!!_WE%6$T7Y-5UO{}tE{W@!|ykYBu)@Dse7HS`*yXO0K(vsfO+I;q&{8NGFJNOFY zqRVtI$yrLJZ35|VXqrQH__n9{nCL$X84AmKYO3%dP2+iHNj{0k~=hsa-!;d&1hRz{65=S?RKk9{&)G!^B4bdtnAZg zJ1;(=fBZS$dx#czj2nZoq34ia>*i}E$5;x#rG1*Gd<3#P;?H^Pt zbUz1w!jDvAqq+QiAFb!tBq@cCaXwdRfhVnU@uCIl?24*~obLJuQYK|)rDp_|j-Qz0 z&7Cr1^0f8YGdJWHPv5xGs9?;VYO1T2EOiH5Ii-c#j0FzWJ{4ouK!S>jOXdf1^9xe% zaycEI@jgHQOiF5*Bg>h=%cDP-QS9kZG`G|IRbmu--~3%%MiUDE3SgJ)9Iwx*Dqdf?;?u8tkWUXp z-3}AZUMW*ZcPr=n@9cIPgHO%B2UMqYM(*L}-v#Ejm6XG`e-H7GM8!{){9CR08`=i0 zd@(;{Di66I|B|*T){WTMSx&jc#;Pd%yTXmsr||W#AWnbmc;D1&PnO@|`-4nh9L0UY z?zdg?r}9(_$?!(QEpmbWzqTUPG=`dV{w$Xag8K*Adq zHh=&GAOHafKmY;|fB*y_aEAyCGylKV%Kz7J{=YW78u|Y_CI9cU^0V!If4%b?C^2Or z=e3D*aAds0784xd;{HK0bkSAV`Tx}4%39z20)K4&|NAucOOgN2QpzO3Bl-UnzgkC6 z82NvhHdBx?Xd@@4BvYwgm;aY|9u-o6$AGu4tf{~uk+AU*Y!76U%r1jy%rs?=D$k;W$u%Fx8=&~?@{=ZKSV#~hne5L zo97;opP&vcasEF#`_Gw=u`RLb|2bn@eZty`Q%eH5ly7AJpuWcl*~R% zQD+X4|93>^|2g~533@a8Kkyf_8|-Xs`hUzDNYFpd{BzFV%>KvucwmBBMjw{^KPMP7 zGcug=0RS!89{{*r^8aQ!Sw7Y`_WA$eUUTN(10GfK|8fsE|1L1k{b2cjxvxteJ&zwU zm3y%~elGcce%aea;hS>2e7n8faHmqAW zvj0fhPn7?UZCC2Q5#QMQ;x6B+{J+tuFG>EtAIQl6_b=XAb9czwcsL9QKmY;|fB*y_ z009U<00IdGhME7bG4lUw!}Uh~za}dG&+FpvAxc&VA=Jg`EGd;E|pD_Mcm(WweI#{||7?=;C$x ze~HV;_3Ws)F|OVEegLV_EJNh~t?2N^|7R-iRmcuJ{@^sR8vp;sTkqOgcxI17 zID$}r{$F;|c>Mq1Wx0HuOp4pBIW?#IpXT`gf6Ms)-j6ekP~!am@Uw?gzv7<4`TwJO z$LBo$Kkb|H`sLSi!twvcX4X@G{y&>S(E)4zsO0~7tiI$yX8oD?l}~h-A7+Ys8qeL$ zpS4l?^8Zt;F94XK&YoOR#iRYrZvmLeUjwkg_#S}#i8(jpKLO&=|JCk=w`}-76$f%9 z_n$I8)n|O$g2k7#$t0h5yfb?Ee^Gy4Fd3alR|6AMor=rhRE#eGP&nJqDQU^~b5h)= z@YeunlKpqf*#Dc*AsO}04H|7qyEmbUxK(n?Jn~I%*OV3) zC!u4W813Jag!WTnv|o~h_FZSfjp%w3S{vHL8MJSrz<=n;k%T2U|H8;P|B`UF4Q=9< zpMN?R>DDbe{@gCwhd<6gy#Iz?9FwsG*B@Meas9>h_y6_!n~ZBL+JFEAAOHafKmY;| zfB*y_00E+vw>bY^Up-L?HU*y!9u6K1o(P5xJ`j8|_yj-ugGXg4zp6Xf8eDU5r@RWT z3x@c4ZSWY+JskYb!NokcI`(mVdGm`^Z{JgQPwJAwO@|xaTX7_3|Nd*K?b#=`yt&a$ zp%4-Oqd-@PLN217?#@uxDL2u+27hDcsX(Zuv7x!SI~3?{Zfw}pDI2Um*U%XX9PJ8) zLd_xS>0Nv%)P1CCdD0Hg#boudT?+v*xU&}xKZ0RZYJG~XNj`zOWd+~+qy8hzt zuUviM{FRr_|K+dxtLM+3|KLg=w;AAO>FAMA;0RB9c7)qM+URfgpA2-jG&lI0p9qDz zo0}WX?sW&a{j-}oL!sWIokv1Do}ixErHhUBPnVwH4)mTrU441!*qtGk7}(cI~hjx?U#Df{1b_MATy=7w2C`GB-5AZS2UgE)(FL^ zaO~8Yu42_^0Sna=7gWS&K24+jo!J{K2@R5 z`XkXVR<-VGBG+W)ts03GESQtwRX5S&BI%UrP6|*4ZQ(u}U9dS+yH-NBROzF{XVYBr zah$?&*#|4WdX>~EW#gs|<_p@srK#m1|5l#!eE;mvUN@F{N$HcrGE!O6w0k$HS;~X8 zvc}x`1>RJ8k-U_`8_DzlJxLDA=2(iRvZVB3k=MohLB@J5e5^C9xaH_|X%Zib<$OH9%yYK> zJ}!6Ir^vCEcpb-!Mu_t&;j&@CNw%a6c9;u3P_b+qwoa z)-)IX;Q2p=qZ9Q$CC2GUYy8{V$#IAB!A#j;;rxOW^8A<<$tIdiH*+6VlAt1|qnwXg zUWtw0FGLcrqDDR!%((1CWL#=AOL3|7YGArB|Ap|3TO-Bx*~stf^*j7+9Uf~-{;9yP zyZ8*_qRVtI$x%wBZ31btX_`&7dA6r}Vb=IynX58 ztGZMF^G6k3X84AmKY5qtxdO}hJ;6uzvNMoPxe;}~Vzey_ew!0s>~yMj{&(f|3zz)~@H*O&{)v)YmGQu$KL4aF~cxy72V@A{K^ zm;Q13#REI?j7{9RXS@U3PAeq3kKY(XGc&x|d1VFi@=kd&%cF`7S}nZBhHCg-~Irp}x)eSOZX4Fx4LHm)=(7`Lao+L|Rxojylyd671Aflajz z#ke&Pr=pV5GGAUnVd@@8NiErKyOuGb$TvG@=A7yIcjeCdk{p{P7IpTN zi4MiV*SR!JQ8k5&W=~fJcTw{gIxsEQ`hk$;4asncAeRIREql`^JU#=a4^ z$W3$MUdT_)WVdfNK50^>S8--$*)w^5>^n1tEp3YCw41+5jA84Wzlp+{juWx z({Ot-{}x{#WcvIVt`kL^uMwnyj=Dp`uIrwMm)}O)8fPv+P`}L z?)K6BLR8(}p3ofx%bVK#yQ2EArghiD`|4ZUI``Fgv~KgSY}(zrtFo@&;-H29pH2d3D z?*7VJb9Tg9Zp%QT*Db6E0SG_<0uX=z1Rwwb2teR=7f3Mwzc!rzujBlGeQ-7M|6i2+ zzbBlZ?d<>Soj*W{DhoNUO`L-x;}f>1;3#MJ50jybtisCwr~X=&dddpD(fR-H(zMS- z{y$5pkOYt9|5Lnb13hNs|7F@re#)ecoS2eKr8+48FY$aTA|J=~WKn(f++cp2scSX=g6^Uih2afkhudMukQJnn$rj~FGPN$1+_;5w%|0NnP z|6i;b`Tvo+GHAJPPI-D{{@+ZsB#{4)sAVAkKV#VZ|F_Af%zK=#wp@AR-3s6NL-a#_ znECCy_|^UL6V#@~&;Lhe|2gw9z9l;SKX-hqk6T+wYN;=e3XJT(++&mMBKdzBd;>sn zGW#%9oi$AU-xitw=j=Zx=*{f^&|k=Iu(Q$W|8Z|1PX9Rb&pCfH`yb=>z&N#xJuLZu zPB2c&%(Tl509vwd0JvT9|7JQ_ZtENW{C}e7ocZ^FOO^b;T*J-33(R9bT>f9K>yk&$ z=Z8$?S}c#BO8%eU_Eu5&q8uyVZmpN-RO*xb^jJ&0{JRymrdB&LZ{^R&l>ZMqMAvK8 zpXgM!A5Hu5^8eB8O8qzD8(m+_`CFC$H#+q>$^Q=k8TtQ#*)P_s+x_!9^dABcfB*y_ z009U<00IzzK%xQ(=Kt%A{Qufuqmlowi^%`;ve)U7if0k1EfH=Ar6!076Q9i@?4Pi|8 z&~E-dis8rq%X+J*jFL0{KTG+haX-p3zSl!diOl~$Mca8ibrbhkhMbzm+8Y0#-2A^= zsWCr-FXdr-JeodV-q)H;b7&!(%1Gq?_jUjHe=}aln+zZ4jbapx{~u}m|7&l&ZDrw^ zJqF<@LIe4K*+}E@|HGH%ayyw6r&F_QcIQ9L@&Esl@&A1vW*VXR`TxYThtuwKPUZan zF}>?k9{->Ib$S2t`#Jvje`7uKX(0cfLxG6p*2`m(|L3v#k_VanN8)!r(P4g=DQ@}x zoV)m58>K)0KQ;UX05jD&Q>tosw7>Z+0JHdO05%xk15hwI_h$SjKs@@t*17PO4gaSS zU!LUtQzoQ(jBi`8{E{`z_P8h5BZvPN599@t(T5DxH#ya=IBa&s_yPchv;CZsmV7@a z#XSmt4S*)uf2WN7zX=_ZQUBba(WbO}6Pk!wCAZ8Y|78!8-?ntj*l~x$$=Uz3ESqHi zlS^Ra|6>Z>+Mqf9-$=Pz9kJUzx+-J+$>H(I)cPKPQIG#mt#qMwstJqSPm0uX=z1Rwwb2tWV=5P$##AOHafKmY;| zfB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U< z00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa z0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV= z5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf zKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ z009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_< z0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb z2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwx`FNVPX07Gz6 AzW@LL literal 0 HcmV?d00001 diff --git a/Breath of Fire III (USA).srm.solo_moverse b/Breath of Fire III (USA).srm.solo_moverse new file mode 100644 index 0000000000000000000000000000000000000000..0fa407200e8482133fc12b9a6c34e9b5ec5f2154 GIT binary patch literal 131072 zcmeI*dr(x@9S88=z58B3Hh}m-WdT7qf(x z87Cw%RVIybrnT)j%}l3{>7*txZKr=^nocrFXVOd`W+s_BP8v<8&Lph~x4+-LdjXea zcR^fZ`aR?Bx%ZxX&pG#VAHe?ZS=Ut2txQwaOY7N0npRm+zq+CR?xLc5i;F93t4oTC z63{Vsl=kmQK>JBi+AmH(`_9v$Ml>w}t&MKtG}<>%;6M80NWc=De<5U?e+f9-MmKTG z&p(Zmbn6x!e{L7;!yo4#uD{VY$3!f_{Rj77+<$TZ{eQjxCgL88HXr~22tWV=5P$## zAOHafK!9k?Esnp}SEVa~=D;(7BY{JK{y^~11A(UkPw=}ha8#D^RNbMrz`8@bWGb*B z5ajo|z%ibCIPl#=%Xqpr`f+?^%S)B-+*5Z?^74YsM;hK=-J5mbz}4iA>HS;Z+T@~O zkcj`0zdJ}lCsAKdSFrn}i)ep?ud(Z-KiJyX(9+Tq^!KzhHf-*a4Vun2bOrrKyMw`C zOOW~omK_fE^!5$ZR2>ZlPY#?aJO13gLD!|LdB>kCIq72 zl^4%le&yU>|E9fm?%cT#FAs8?er}eI_6GgEocHYvwSTnH*Wx?j?`dsm@U=V<4ED6N zG@RMz@^kxVHg^Ss14p}hgFBy~zM2)w^!87c^m7LWPMxZ{wBqrTm#&sozFX7J?bqg1 zMQQ(N&}hGpcTw7>fmUPx`+9i4PdIy8xf?BAPU%SFnO(B~-Dl4Fg8qSlwwB(Vy)>}8 zksuQyRAC&c2J|my;qXIOuwetB#%ZY4waLQ zU!}=5=MG*X<;UnD$~VfT_`34yRm)d@r)CAOSy$i4?~+a!8NYX*EwE(h3@&w0Rp|4f zlJJSOZM&PvIZb(6-`9XS$>@=OrlB_CAN*|VboV*{Tuh+`QI?XIM9X(E~lt)U>Zuz=# zB2nthfzS$5N#T#xLW?78w87`=?6A1#kVOjBl3ZSO5#`FU)+EoP9CET0cUgzjosw<# zhj@vU&*A>1j!`Z(hNmrCTf-N{oUik>5n1_ISIDY-U*dF_&oJq->sMH-q9&(`_2caZ%K<-@sBvSd+y61jguOJx(QFx8tZ7U?3Kp0 zUVB>8{`K28em|&b2c<-tYLvHLc>bb8EA6?a9sF!?8hv_Uma$yZ4mkAn{&VHvg*V^1 z_{kN`q5b9K@@}K}hTlJZj}|)pEBTt>BYVl=pHA5$>U>piTNeB-E40|*P;LD0@*C$b z{^NN0C(ra;d`$c3Grso_Eq3ZR27N{6VUM+s&y{R_&M)t3XP#5#TP-&fJLP(vv%G`X zp3=ItPf{-&+?lIy;>tel8QykQ0nvSYVGzwt^Gwez&6mkL<;_Ts9!Y&q(_XK=eBa;c zRdeBpJV;qe(W69N-0knzD0Cl}{g_|L`Z^2w{a$L~Ym$^gON!fGR^UvnTDEktI=`~| zL7SuT{-o(sGt)A>E2d1#cID2TJ7acJR?f!!;yIhv=oL)bTU|}{@)ZuRJ-e*XI(M-} zH4nw4H4vks;*wHtZhk@X9d?_=ImPYapGgT#(_J=e+LS`?ysWwNXXo9Oo%0nrHVI7X zycy|s#m@J+6sw|I6;4)Ls^ZR4EvjNs96Z0B3oMGNSfzCAAE6WKG}kCqtE%LZCREGB zH{uq#X-?b=`Kg)c_Kn7;PR;Nrj*LuO2G37?XC|k;Y<6qErC3GX!HQnf9SRAE4 zX8BMaYES0h=KF)>FHGP*VfNdsccLESZC~0o`)%g`mHpu5vLE5cN9xzhV;nbYjPkhl zuim$(V|>35Rdsa4^#sAH=62uius*D7+x_tV`nLA2{q>z~+kI=A_q6ScBg zmnHu14#j7?hW>iz4^YC=5{_#V$KXi+ge|OaoU;caMCe9VVaETHeUHsdDbJ%q@^X2^_`g)Cr^$)` zzrS26s~Z*n|D5ChWXAUq|JTJMz1=?X|4h1CC40c}e~+s8s8)~vOa3giQ##4ViKFBH zQeHuKQ&w1ceDVKbF~t9G*Z4m_6+s`D#}`E(KHg(ZneqR^81etjt)Utm4kthG;S7)e zOKGh5f00#>|Buy`>y~@xm!*!3{~Mu}IO6{!Y8j6I&xsiSf0De)!pHe;%au3Yt?-jS zL_gw}5#PRxr|y@ZpcZTF`2Wc0KSw?$H-(4)7ff#TF>5PMF7f74z8?LTXKWIkB>qp= zKLAja$Ue+eb0Wn5EhFRq9R242y%GH%{R`O*b~ZfxKj{s`=pRS^Ip%Lf|D!w}7^9Yn z7fbw~1B_EMGHmhyfHlz%0NgI|eq8gCurqdoMNst;k@8#^i7S=`({~wx?k3l_2QbF}OTCjZ{@{XCAJ_Q*lo;c!Z=do1nM%n6;^&gTEeC>5_#yl9vc5|lo#+Ok;{3bC<){L#~T0t`kU{V zQFvyLLO711;rPF7WaaVyk<%)9oJ^9#VYOLpj(-~C|NkxH{|7(H(2HWn|KpDy&brev zljHx#wC>M%{D0~<<@)98IrjK}eLdrCIR2kS{t?T~$zu}#=dt<{2buRL;wzu%2)~RF zw|sxjUHq(#G8F%x8TtZ%x$68GmDN1j-}n}Q9R3=Bjr#WhU|7M4gLjVF0h$Rs3=VVw90uX=z1Rwwb2tWV=5P$##AOHafKmY;| zfB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U< z00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa z0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV= z5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf zKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ z009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_< z0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb z2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2teS=A@D!2 CB~l9j literal 0 HcmV?d00001 diff --git a/Breath of Fire III (USA).srm.todos_los_armarios_abiertos b/Breath of Fire III (USA).srm.todos_los_armarios_abiertos new file mode 100644 index 0000000000000000000000000000000000000000..177719ed2eebc57bf854d0ac4c3b4f9886d3cb3f GIT binary patch literal 131072 zcmeI*eQXow9S88=ozJfc#0??51&B#V2yI82bU-LwnuG?zTOc9fZKDg|gwTv+43bc) zVq7Su5^7qaLe!NaZEO=-rD-pkI@;20+8@Q^?@-(6gMZ%IjIZFOmJ zaSA%-iPQc)DQG_}PWvS(Xy0`@+=#BHptaa0PNRJj1^%%oM+%nU{0k%F{7b>v7Td%v zKmT-2(yd!`{JCAU4}YA0xc*{qj;UCJ`w#BFxc}n*`~Q0XO~pMHZ9o755P$##AOHaf zKmY;|fB?~|TO5C{ubQ9)n}W{-4+jqhdxN2a4+NhIKEcoa;89u1Q*{ShgKG}%l&Rpl zV2GdB29NRF!@*|{F5$V__{Z_p%`aEJdr#dx=}QYY9d7tw<&m8I`>&?APww6F_C_~_ zLPY$J0$m{rxrlnYJ40P3-9-Bu{EeL_1EH42hUVt(P@ucHv0+oEY_R@pLuV*(v?~+} zHHWCDZ^@xh_mQ5ynyRCr(8<12WyhbtH{`x_HUIeYr6=9*^_9;$-uHUng_o}B`pbX3 zeC4HcmtQ^ix4-MJpF4N%qs#r=W`LWeqenu4Bb@i_2)BQ<(ckPp5$JAdZtyoh5ejuT zH#eNw>ke@HXEt?)LVZU&kA!wSK|M9gmKg1yD(&SC^qo3Yb!pk-Cof$st9-Afm)ozM zRTZcGqam~X9^OT1pZZ$N{qO1K{XXI9ZsBe;cekkF``dXWh>^MSw zD@zZBx_JLTEUP*p`~P8C@2Nx5eqQhMM*Ddsy)T&ie?E5q(@2$8Ba#v^ZB8yBQYbK; zXTC*Fmp!I@BnzHg5r6HveS3+VGi>wzB&mNFEM57%nq|CZU40`zOFCg@{M>c6(3bU}%(~TnRiQ5i zN}?xLx9(~p*CgegYAGpLI49GqZlcFU(kb~)3Q#6(;XWH(usKw_RzkLP>7$g-rn%(f zatfErK3L_otEEm!8#iq*CusYYrk02NTY1j&!!y5l(^%>yrC$!qaA|4N?%kwjD-YJl z8gu6tc+=@+@=_XaB>4e)iX1eV%hEKJC8ZCGy)NDlGS+M1W1VT0TaI3rCgnq==Qe*c zd?IB`?F+9kkre(|E&BW#+y6{v*)7A&VlLJ{+g7a}z`*+&OK1unNaqcXiUzDjT zJE@+JFWDqNP5WsQHFJHAfj-XRosmmX%ByJ}TV7v2gZElaZ@y;2{aC!DZvDe;>l(;d z(_HwY7ylA2ouKzCaZX2C-v7DvEF~K9Juh-yB9yb zqC54!ep23L7T@smXYbQIS713`6MSSZIRld^H=@qhjJ9RL?{mV7ole!x|1Q6I{^CE5 zmw)<9_r=Hbk3Z*o579!Gabqx6bRF_)J$$a@8gl`8Ry*=tD&K0kp~NXKw^;M_UwcaL z(m&0(a9~HCv57nPw0CgZX@x}h@r6M&Gt)acZ$W`f-YHLJdh~F{`w}laAWxjE&dHj4Yt>usK^z}KjHWZZ1*tp85V9cKCYO0qmbNU>)WkuS|g*MeX6l2yv zf{IE?7x?lD3e)d!*ln)y9xwk*N@<$xwriQ=i+r6TugS4VVNz#Lncz?y ze4iVqDXOM$((DF|F-N7ZSrQL0u|$t8`dmeFs-EppSG zxEJzQGu7>zjZd7IqhI$RkM1+?hRHo&DOX5$D(469>{c5?=jQtX)h?Zpd${?&z+AVAa{2b}BL0)8 zc&UnC)tax+HgM%j_#wGGU8~<#{$JS-UM~9)eSD;TqddWJ(-M>?wSV>g-R&cL zK~&Y=9{YM=h_+TVwfT2NEnm~R>*0O%t!N{Gu`BydVZrxSU*0G~0YQ3o0ijIyp z|GK?xtsPMXL(Ou{dmb68z*x4vscpMn=ilnrH@0@@di}PhJ^GsFroHAXoQjTSf7`0v z-&h;-f@jzYZ=ZtX?pjz20uX=z1Rwwb2tWV=5P-n#FOX#Xe{DGaU&rzP`d}^M|6i5( zzb71@?HqW^&L5yer9~XqCXT_8@d;a0;Rt8<4-uh@tip=_r~g)#dKMIVqvQYIr)gh` z_|G(h)KUwj8#QzQPp`LD^_i;lmXj|CiE4 z@&97Yi2o1QmFt%K=9Fbb#{bPwOA_(_h+53}{~NWJ@0&rdMJ%@_pCq3$?{U7{a^;P8 zEBwtLq960ajBnq?Q}@eXP@9%G{vR3r=g7y{rs(kh+_9}bVQnSprM^5WFrxqR9h+1q ziT~5}UjQghWgn)hvxbQO+alxt9R242y&3(FeL;4EosACvk9h+L`p1!fj`^F>|2SU{ zOi;_{izWWg0mg}0S$6pXfR^en0NgI|e>0pcU+WwD_q^hx7v|;D}Fwz z_Z&m!?=+u`a{yzw0#Qz6pzgknb|0j6Z z0|-C>0uX=z1Rwwb2tWV=$q6JG|F1LR|7(MdM*P1nBL2_I;=d!r`2R2S_JNe^3r{v|d zhU5SDbD7b_>*D`XE+f}-BFc?%?cv`CkQ&W2O#DAwn%wyRiOPGGvH_3(_bB`s=s1Z* zX_6nJAlXR<3-kDYPSS@3UY9Z6TFSTbi0nIJ%SSZ+e_Vp`*0<02|7@l70daIMEZ_^} zQ9i@?f-v$uw3~mAV(9VzvfgT1K&cu3pRIh?_&&;V{;r3b78(D4nzr+J>L%{73^_HA zwKe`fwef$qQf+<&U&_Pwcr<;!T-Tc9IkbpPWhC;zbv-ct-z+cWO@=P#jp8JX{~vDr z{~K?;YenIiJr3ariU#BVvXRE)|A$U1Z)0JHdK05%xE15hw2_h$SjKs@@t z#<}R04gaSSU!KJN)5fQJj9*)@{8E)q_PEE}BZvPN55@&k(T7acH!0n&IBa&s_yGWg zqx~F`mUur0#XSoD41gxlf2WN7zX=_ZQUBba(WbO}6Pk!yCAZ8Y|78zT-?ntj*l~x$ z$b;NG>=&FqMCx^!;x%E2$BOd=hj>rEibUs;e z^Zh`YU4Fhs?&0S90<&8~#s94iBZmM4AdpBPxlhTk76c#w0SG_<0uX=z1Rwwb2tWV= z5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf zKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ z009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_< z0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb z2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$## zAOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;| zfB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U< z00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa z0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX?} HS4H4|p5IsP literal 0 HcmV?d00001 diff --git a/abrir_armarios.py b/abrir_armarios.py new file mode 100644 index 0000000..5f4699b --- /dev/null +++ b/abrir_armarios.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +import sys + +# Rango del checksum +desp = 0x2000 +numBytes = 0x2000 +firstByte = desp + 0x200 +lastByte = desp + numBytes - 1 +checksum1 = desp + 0x270 +checksum2 = desp + 0x271 + +# Bloque de armarios +ARM_START = 0x02930 +ARM_END = 0x0293B + +# Armario que quieres dejar cerrado +TARGET_BYTE = 0x02934 +TARGET_BIT = 0x80 # bit 7 + +def calc_checksum(buffer): + total = 0 + for i in range(firstByte, lastByte + 1): + if i not in (checksum1, checksum2): + total += buffer[i] + total += 3328 + buffer[checksum1] = total % 256 + buffer[checksum2] = (total >> 8) % 256 + +if len(sys.argv) != 3: + print("Uso: python3 abrir_armarios.py save_in.srm save_out.srm") + sys.exit(1) + +infile = sys.argv[1] +outfile = sys.argv[2] + +with open(infile, "rb") as f: + buf = bytearray(f.read()) + +# Abrir todos los armarios +for off in range(ARM_START, ARM_END + 1): + buf[off] = 0xFF + +# Cerrar solo el armario objetivo +buf[TARGET_BYTE] &= ~TARGET_BIT # FF sin el bit 7 → 7E + +# Recalcular checksum +calc_checksum(buf) + +with open(outfile, "wb") as f: + f.write(buf) + +print("Hecho:", outfile) diff --git a/abrir_armarios_extendido.py b/abrir_armarios_extendido.py new file mode 100644 index 0000000..002d65b --- /dev/null +++ b/abrir_armarios_extendido.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +import sys + +# Rango del checksum +desp = 0x2000 +numBytes = 0x2000 +firstByte = desp + 0x200 +lastByte = desp + numBytes - 1 +checksum1 = desp + 0x270 +checksum2 = desp + 0x271 + +# Rango ampliado de armarios +ARM_START = 0x02920 +ARM_END = 0x0293F + +# Armario que quieres dejar cerrado +TARGET_BYTE = 0x02934 +TARGET_BIT = 0x80 # bit 7 + +def calc_checksum(buffer): + total = 0 + for i in range(firstByte, lastByte + 1): + if i not in (checksum1, checksum2): + total += buffer[i] + total += 3328 + buffer[checksum1] = total % 256 + buffer[checksum2] = (total >> 8) % 256 + +if len(sys.argv) != 3: + print("Uso: python3 abrir_armarios_extendido.py save_in.srm save_out.srm") + sys.exit(1) + +infile = sys.argv[1] +outfile = sys.argv[2] + +with open(infile, "rb") as f: + buf = bytearray(f.read()) + +# Abrir todos los armarios del rango ampliado +for off in range(ARM_START, ARM_END + 1): + buf[off] = 0xFF + +# Cerrar solo el armario objetivo +buf[TARGET_BYTE] &= ~TARGET_BIT # FF sin el bit 7 → 7E + +# Recalcular checksum +calc_checksum(buf) + +with open(outfile, "wb") as f: + f.write(buf) + +print("Hecho:", outfile) diff --git a/detect_armarios.py b/detect_armarios.py new file mode 100644 index 0000000..53778e3 --- /dev/null +++ b/detect_armarios.py @@ -0,0 +1,85 @@ +import os +import sys + +def load_saves(path): + files = sorted(os.listdir(path)) + saves = [] + size = None + + for f in files: + full = os.path.join(path, f) + if not os.path.isfile(full): + continue + with open(full, "rb") as fh: + data = fh.read() + if size is None: + size = len(data) + elif len(data) != size: + print("Tamaños inconsistentes, abortando.") + sys.exit(1) + saves.append(data) + + print(f"Cargados {len(saves)} saves de {size} bytes.") + return saves, size + + +def is_one_way_flag(seq): + """Devuelve True si el valor nunca vuelve a 0 después de ser 1.""" + seen_one = False + for v in seq: + if v == 1: + seen_one = True + if seen_one and v == 0: + return False + return True + + +def main(): + if len(sys.argv) != 2: + print("Uso: python3 detect_armarios.py ") + sys.exit(1) + + saves, size = load_saves(sys.argv[1]) + num_saves = len(saves) + + # Transponer: valores por offset + flags = [] # lista de (offset, seq) + + for off in range(size): + seq = [s[off] for s in saves] + values = set(seq) + + # Solo nos interesan offsets con valores 0/1 + if values.issubset({0, 1}) and len(values) > 1: + if is_one_way_flag(seq): + flags.append(off) + + print(f"\nEncontrados {len(flags)} offsets que parecen flags de armarios.\n") + + # Agrupar offsets contiguos + if not flags: + return + + blocks = [] + start = flags[0] + prev = flags[0] + + for off in flags[1:]: + if off == prev + 1: + prev = off + else: + blocks.append((start, prev)) + start = off + prev = off + blocks.append((start, prev)) + + print("Bloques sospechosos:") + for a, b in blocks: + count = b - a + 1 + print(f" 0x{a:05X} – 0x{b:05X} ({count} bytes)") + + print("\nSi ves un bloque de ~80 bytes, probablemente son los armarios.") + + +if __name__ == "__main__": + main() diff --git a/detect_bitfields.py b/detect_bitfields.py new file mode 100644 index 0000000..e69de29 diff --git a/diff3.py b/diff3.py new file mode 100644 index 0000000..ea2fe21 --- /dev/null +++ b/diff3.py @@ -0,0 +1,23 @@ +import sys + +def load(path): + with open(path, "rb") as f: + return f.read() + +if len(sys.argv) != 4: + print("Uso: python3 diff3.py A.srm B.srm C.srm") + sys.exit(1) + +A = load(sys.argv[1]) +B = load(sys.argv[2]) +C = load(sys.argv[3]) + +if not (len(A) == len(B) == len(C)): + print("Los saves no tienen el mismo tamaño.") + sys.exit(1) + +print("Offsets que cambian SOLO al abrir el armario:\n") + +for i, (a, b, c) in enumerate(zip(A, B, C)): + if a != c and a == b: + print(f"Offset 0x{i:05X}: {a:02X} → {c:02X}") diff --git a/diff_saves.py b/diff_saves.py new file mode 100644 index 0000000..e856bcb --- /dev/null +++ b/diff_saves.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +import sys + +if len(sys.argv) != 3: + print("Uso: python3 diff_saves.py save_antes.srm save_despues.srm") + sys.exit(1) + +path_a = sys.argv[1] +path_b = sys.argv[2] + +with open(path_a, "rb") as f: + a = f.read() + +with open(path_b, "rb") as f: + b = f.read() + +if len(a) != len(b): + print(f"Los saves tienen tamaños distintos: {len(a)} vs {len(b)} bytes") + sys.exit(1) + +print(f"Comparando {len(a)} bytes...\n") + +for i, (x, y) in enumerate(zip(a, b)): + if x != y: + print(f"Offset 0x{i:05X}: {x:02X} → {y:02X}") diff --git a/info.txt b/info.txt new file mode 100644 index 0000000..0afe91f --- /dev/null +++ b/info.txt @@ -0,0 +1,149 @@ +=========================================== +DOCUMENTACIÓN DEL SISTEMA DE ARMARIOS +=========================================== + +Juego: [Nombre del juego] +Autor del análisis: Sergio +Colaborador técnico: Copilot +Fecha: [poner fecha] + +=========================================== +1. INTRODUCCIÓN +=========================================== + +Este documento resume todo lo descubierto durante el análisis del sistema +de guardado relacionado con los armarios (contenedores) del juego. + +Incluye: + +- Localización del contador global de armarios abiertos +- Identificación de flags de evento relacionados +- Confirmación de qué offsets NO son armarios +- Estado actual de la investigación +- Próximos pasos recomendados + +El objetivo final es permitir manipular el save para: +- abrir o cerrar armarios individualmente +- forzar el logro de “abrir todos los armarios” +- depurar el comportamiento del juego + +=========================================== +2. CONTADOR GLOBAL DE ARMARIOS ABIERTOS +=========================================== + +Offset: 0x0295C +Tipo: contador simple (1 byte) +Función: almacena cuántos armarios ha abierto el jugador + +Ejemplo: +- 0x3B = 59 armarios abiertos +- 0x3C = 60 armarios abiertos +- 0x50 = 80 armarios abiertos (valor máximo para el logro) + +Este contador: +- aumenta en +1 cada vez que se abre un armario +- NO depende del guardado +- NO es un bitfield +- NO controla si un armario está abierto o cerrado +- solo refleja el total acumulado + +IMPORTANTE: +Modificar este contador NO abre ni cierra armarios reales. +Solo afecta al número que muestra el juego y a la lógica del logro +(si el logro depende únicamente del contador). + +=========================================== +3. FLAG DE EVENTO RELACIONADO (NO ES ARMARIO) +=========================================== + +Offset: 0x02934 +Cambio observado: EE → FE al abrir un armario concreto +Bit afectado: bit 7 (0x80) + +Este byte: +- cambia al abrir el armario de prueba +- revertirlo hace que el armario vuelva a aparecer cerrado +- PERO no forma parte del bloque real de armarios +- es un flag de evento o script asociado al acto de abrir ese armario + +Conclusión: +0x02934 NO es el bitfield de armarios. +Es un flag de evento que se activa al abrir ese armario concreto. + +=========================================== +4. BLOQUE REAL DE ARMARIOS (AÚN NO LOCALIZADO) +=========================================== + +El juego tiene 80 armarios → se necesitan 80 bits → 10 bytes. + +El bloque real: +- NO está en 0x02930–0x0293F +- NO incluye 0x02934 +- NO se ve afectado al poner FF en ese rango +- debe contener exactamente 59 bits activos en el save analizado +- debe cambiar un solo bit al abrir un armario +- debe permanecer estable al guardar sin abrir nada + +Estado actual: +El bloque real aún no ha sido identificado, pero sabemos que: +- está cerca del rango 0x02800–0x02B00 +- debe ser un bloque compacto de 10 bytes +- debe tener valores tipo: 00, 01, 03, 07, 0F, 1F, 3F, 7F, FF +- debe contener 59 bits activos en el save actual + +=========================================== +5. RESUMEN DE HALLAZGOS +=========================================== + +✔ 0x0295C = contador global de armarios abiertos +✔ 0x02934 = flag de evento asociado al armario de prueba +✔ revertir 0x02934 cierra el armario visualmente +✔ el contador global NO depende de 0x02934 +✔ poner FF en 0x02920–0x0293F NO abre armarios reales +✔ el bloque real de armarios NO está en esa zona +✔ el contador global coincide exactamente con el número mostrado por el juego + +=========================================== +6. PRÓXIMOS PASOS RECOMENDADOS +=========================================== + +1. Volcar el rango 0x02800–0x02A00 para localizar el bloque real. +2. Buscar un bloque de 10 bytes con ~59 bits activos. +3. Confirmar qué byte cambia al abrir un armario nuevo. +4. Mapear los 80 bits → 80 armarios. +5. Crear un editor que: + - abra/cierre armarios individualmente + - actualice el contador global + - recalcule el checksum automáticamente + +=========================================== +7. CHECKSUM +=========================================== + +El checksum del save se encuentra en: +- 0x2270 (LSB) +- 0x2271 (MSB) + +Se calcula sumando: +- todos los bytes desde 0x2200 hasta 0x3FFF +- excepto los dos bytes del propio checksum +- más un offset fijo de 3328 + +=========================================== +8. ESTADO FINAL +=========================================== + +El sistema de armarios está parcialmente resuelto: + +- Contador global: ✔ localizado y confirmado +- Flag de evento del armario de prueba: ✔ localizado +- Bloque real de armarios: ❌ pendiente de localizar + +Una vez identificado el bloque real, se podrá: +- abrir/cerrar armarios a voluntad +- fabricar saves para logros +- documentar completamente el formato + +=========================================== +FIN DEL DOCUMENTO +=========================================== diff --git a/revert_2934.py b/revert_2934.py new file mode 100644 index 0000000..1b8b010 --- /dev/null +++ b/revert_2934.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +import sys + +desp = 0x2000 +numBytes = 0x2000 +firstByte = desp + 0x200 +lastByte = desp + numBytes - 1 +checksum1 = desp + 0x270 +checksum2 = desp + 0x271 + +def calc_checksum(buffer): + total = 0 + for i in range(firstByte, lastByte + 1): + if i not in (checksum1, checksum2): + total += buffer[i] + total += 3328 + buffer[checksum1] = total % 256 + buffer[checksum2] = (total >> 8) % 256 + +if len(sys.argv) != 3: + print("Uso: python3 revert_2934.py save_in.srm save_out.srm") + sys.exit(1) + +infile = sys.argv[1] +outfile = sys.argv[2] + +with open(infile, "rb") as f: + buf = bytearray(f.read()) + +# revertir el posible flag del armario +buf[0x02934] = 0xEE # valor original + +calc_checksum(buf) + +with open(outfile, "wb") as f: + f.write(buf) + +print("Hecho:", outfile) diff --git a/revert_armario.py b/revert_armario.py new file mode 100644 index 0000000..2be52fc --- /dev/null +++ b/revert_armario.py @@ -0,0 +1,38 @@ +import sys + +desp = 0x2000 +numBytes = 0x2000 +firstByte = desp + 0x200 +lastByte = desp + numBytes - 1 +checksum1 = desp + 0x270 +checksum2 = desp + 0x271 + +def calc_checksum(buffer): + total = 0 + for i in range(firstByte, lastByte + 1): + if i not in (checksum1, checksum2): + total += buffer[i] + total += 3328 + buffer[checksum1] = total % 256 + buffer[checksum2] = (total >> 8) % 256 + +if len(sys.argv) != 3: + print("Uso: python3 revert_armario.py save_in.srm save_out.srm") + sys.exit(1) + +infile = sys.argv[1] +outfile = sys.argv[2] + +with open(infile, "rb") as f: + buf = bytearray(f.read()) + +# revertir el byte del armario +buf[0x0295C] = 0x3B + +# recalcular checksum +calc_checksum(buf) + +with open(outfile, "wb") as f: + f.write(buf) + +print("Hecho. Guarda generado:", outfile) diff --git a/revertido.srm b/revertido.srm new file mode 100644 index 0000000000000000000000000000000000000000..f3a8480fb1c406b8b10da35f78f7f38768e51991 GIT binary patch literal 131072 zcmeI*d2AH-6$kJ)v-jHIjq$-@z-t>DlcYFy3K&QoA2FC48=I?z7+4z<7rPW}6QZze zAYNBOae`H_(h#JSwnB|m^-z_PgtSush?*)C=0Z13COvbvJ)WSP8PTF)lZw2Jb&RrPiE78TuJTwJlXx}>Nm z0UdKkY5%?iw4W5E{o(|)?>rM~MAH(`+Q=r(pnU@c{v%J01kAzt7edDQmw>ZvWD|G% z{L{Edx9-sK=XTLP{Bi!_`Wtz3OvD`Ae{lcB{TKJ&|JVC(BJQzh0|F3$00bZa0SG_< z0uX=z1c+AO;rx4Dy7YH7CFz{61Nq+VPdSouYsy)&YSa)QPyb5dx z1oh|RJoQN6`$wvHYHjr6`0Cb|E8e}Y_P*q01zV2Qf3T`M>(HTV$!$~nw!OXCMZq8u z|092Akb+L4-mZ>d=P4J_!Fpdq$0>iXxuL$PsVnI3YHFz8(jhBsJXhZl^!IcIgTbaC z_4ZdC4R&?+_SaPQ1cRsgPnVu}?*5?b^0mAZ&y}2Vz1LrsbE5zC{);bN*R+@aaOLVt z=dZka{;z-2UO#{S{6|*?xJ^GdOFi8|e>c~?yF=~wH29i)C;eT`P4&K}CxgMRrl$I{ z2V8z`|Lm5IV6eZZqdU0!N$RaxUZuBxx}=Xg(0}@L<>lp1oVt9iwBo&*K5l<)PGyw# zdxA#$y}XOkKJ_;n``_Ee`+d^c)y&;!>TpU&8qV&K{qH<`&KLCe_qQ~4@9w7lRV7D* zoxJ}amR6pW{r|AE@AOe=Kez8Wz5U$czUPhozc6zDlSq|T=>`2+o|M5?=8Gzs>7U7y z-y(<8X3ic{{cv^k)oKqOAacyI%>Sb-=UzN7HEGJ*v_|ih)UVKQXeP-=BNT_q#m0|? z$u{RMo+I(&w4L&exP)(rSFc>Q>bo_|dCA(k27Z=u(x~{k^IU-??ID?TsROD)UkpaV zU#w}_+epq#4dKWBq)n+XwOS1G);&W&oc{xs@ zxa@-&U%SR^ZS$5*p_jY1H8yYe?cgc*56}MMO?|G1lz~Xc%3OO{X_a`S^6b`c8YdE^ zOz#gZkWLD}trnUcVWkZ|UwfOyMMo?WR7-Ms(FK$%$6Av*k8;S#Qru-7Qg=$W*|+l? ziO=HxrHm4nEryq^+nU2?#hkA7wGdhPSeMJ9d|%>nl+Q5fveaEv%E$BTJY^Z|<4U`2 znjCA1*K)jYlsGREDw{TL2)!zA-0@)Oym{f$KTec= z`b^iQ$F+|?=X(#)BBy?1&=+(b^;moPT*=m_{PL`}=Q&lr)pA3zOK$G;bnn3Rr?gJ( z)0B&ccjxM>xU$c9hSr@?K(vG}45Hboo~gMD^X28;@?@09j-|Y>X>Y6@Sn_vz&73)` z4pNp<^cYbGcl(7Jg_dyaC;Uj(mzmGc_tQqcCap@LWs=)oTHs8ntXjHAom)};kj>HX zK+@FojMOym^2wRmuH5Ofr_J1$m9r_oc-H3C`Ub}BskWwi*>Z>1o?TjKoxRASnulWC z8i=u>;*y2l-28&%yX-cLbF$mRKa&z#rn+p_)X9b3Ia#yk&dj?fJLhY1Y!X*ysB@-G zu`71I&rPx_s#W1)wWTQTEY+ea7RABSJ2_xcRK+UM(SL-Fsnfhg*|e%kEoDqw8T(4y zA~(&2dm%qH6WzYiczSx8M{%TO*wT1<>^n1tH7$zOVKaV}7{l7Pe-*plgu=f9m?bOQ z<+iDc%U!OxwHqGf*1Yl=ig?S_GKDmUa$)GsZnhD*HvS$^ZPFRJhZ}zv7|T{tHsAi8 z#6J=h4^{GSwZ?B~n|R|@{E%86azFkh?NmZHVtr*fri_#{SMzBq<(P>_X)G#=61*GakK49yJo-5`oFRtJYV)B{P@WB^>~cqW{nY#Yyawe z``T{q7oy6xwzxh)u(Gk$w>PX0>st0cac)L7d&^tfcQ=MD7dBbm z-rnllaGzW!5XnM4~y~)?Q zdfzwJ8DST2tWV=5P$##AOHafKmY<0T_Dc<|N2n=zn1g=b%C`3^&-UYj@vNBTQ#VZoc6JQN{AH+&Oj{y+J*GS|JZz!RST{{hYT zQsngn{66ykx_G3giIe}&plg+~2b}-+sEUu)>iK`EpQTosLh^Rv$o#*= z%jsUq3X8{={~r=V{(qw8|M^o9^hsHKS@fafJ=!ZX|6dp*|G%XkJm|H7OF7f74zMlP;&)6ioNdBL0 z`~W~vBKt61&54lzw+zq!bM~JT^hWl7lh=l|n9=ZwDxoT}viR( z00Izz00bZa0SG_<0`UsOng6fV^Z)Au4SN2+c3A$O=SBaE5aa*9%;W!Ep*LVT}df(|Eixj}Xz5 z>oO*MWoZ1r#2@AH%z0sP^ZNme@&B^j@fiQ_QC^uM+wv|baqXe+2aqiqWt9AXC>r1R|8(WO3R!{2|GO1_4|I~`qO4LM zr2yGT1`G4}e=gF8g&wCq-df^2ctrMHBjYzU{(n-8@zxV({C|d0@}M}n7UlDW@))0C zd_m~-e%i<1M-h4azbvGS#6Gg8sq=}E#vH_|KnQc=RE#D{}W4~=l`P$-Pxcq{$EeIn;o&)+?pz5{mJh3N^O1*z)g?;pTy(;6}k|wxbgQu zl1;w8M(*Lp-vvguBIW 225 veces - 0xA0 -> 9 veces - -Offset 0x00185 (389): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x20 -> 225 veces - 0x00 -> 9 veces - -Offset 0x0018A (394): - Valores distintos (2): 0x00, 0x42 - Clasificación: small_state - Más frecuentes: - 0x42 -> 225 veces - 0x00 -> 9 veces - -Offset 0x0018B (395): - Valores distintos (2): 0x00, 0x41 - Clasificación: small_state - Más frecuentes: - 0x41 -> 225 veces - 0x00 -> 9 veces - -Offset 0x0018C (396): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x53 -> 225 veces - 0x00 -> 9 veces - -Offset 0x0018D (397): - Valores distintos (2): 0x00, 0x4C - Clasificación: small_state - Más frecuentes: - 0x4C -> 225 veces - 0x00 -> 9 veces - -Offset 0x0018E (398): - Valores distintos (2): 0x00, 0x55 - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0x00 -> 9 veces - -Offset 0x0018F (399): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x53 -> 225 veces - 0x00 -> 9 veces - -Offset 0x00190 (400): - Valores distintos (2): 0x00, 0x2D - Clasificación: small_state - Más frecuentes: - 0x2D -> 225 veces - 0x00 -> 9 veces - -Offset 0x00191 (401): - Valores distintos (2): 0x00, 0x30 - Clasificación: small_state - Más frecuentes: - 0x30 -> 225 veces - 0x00 -> 9 veces - -Offset 0x00192 (402): - Valores distintos (2): 0x00, 0x30 - Clasificación: small_state - Más frecuentes: - 0x30 -> 225 veces - 0x00 -> 9 veces - -Offset 0x00193 (403): - Valores distintos (2): 0x00, 0x34 - Clasificación: small_state - Más frecuentes: - 0x34 -> 225 veces - 0x00 -> 9 veces - -Offset 0x00194 (404): - Valores distintos (2): 0x00, 0x32 - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0x00 -> 9 veces - -Offset 0x00195 (405): - Valores distintos (2): 0x00, 0x32 - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0x00 -> 9 veces - -Offset 0x00196 (406): - Valores distintos (2): 0x00, 0x42 - Clasificación: small_state - Más frecuentes: - 0x42 -> 225 veces - 0x00 -> 9 veces - -Offset 0x00197 (407): - Valores distintos (2): 0x00, 0x4F - Clasificación: small_state - Más frecuentes: - 0x4F -> 225 veces - 0x00 -> 9 veces - -Offset 0x00198 (408): - Valores distintos (2): 0x00, 0x46 - Clasificación: small_state - Más frecuentes: - 0x46 -> 225 veces - 0x00 -> 9 veces - -Offset 0x00199 (409): - Valores distintos (2): 0x00, 0x33 - Clasificación: small_state - Más frecuentes: - 0x33 -> 225 veces - 0x00 -> 9 veces - -Offset 0x0019A (410): - Valores distintos (2): 0x00, 0x30 - Clasificación: small_state - Más frecuentes: - 0x30 -> 225 veces - 0x00 -> 9 veces - -Offset 0x0019B (411): - Valores distintos (2): 0x00, 0x32 - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0x00 -> 9 veces - -Offset 0x001FF (511): - Valores distintos (2): 0x08, 0xA0 - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xA0 -> 9 veces - -Offset 0x0202D (8237): - Valores distintos (8): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56 - Clasificación: small_state - Más frecuentes: - 0x4F -> 50 veces - 0x50 -> 40 veces - 0x51 -> 35 veces - 0x52 -> 34 veces - 0x53 -> 34 veces - -Offset 0x0202F (8239): - Valores distintos (10): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58 - Clasificación: bitfield_like - Más frecuentes: - 0x50 -> 37 veces - 0x54 -> 34 veces - 0x55 -> 26 veces - 0x4F -> 25 veces - 0x58 -> 24 veces - -Offset 0x02033 (8243): - Valores distintos (6): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54 - Clasificación: small_state - Más frecuentes: - 0x4F -> 50 veces - 0x54 -> 43 veces - 0x53 -> 37 veces - 0x51 -> 36 veces - 0x52 -> 35 veces - -Offset 0x02035 (8245): - Valores distintos (10): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58 - Clasificación: bitfield_like - Más frecuentes: - 0x55 -> 40 veces - 0x57 -> 36 veces - 0x54 -> 28 veces - 0x51 -> 25 veces - 0x50 -> 23 veces - -Offset 0x02041 (8257): - Valores distintos (6): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54 - Clasificación: small_state - Más frecuentes: - 0x51 -> 66 veces - 0x52 -> 60 veces - 0x50 -> 50 veces - 0x54 -> 26 veces - 0x4F -> 20 veces - -Offset 0x02043 (8259): - Valores distintos (10): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58 - Clasificación: bitfield_like - Más frecuentes: - 0x50 -> 36 veces - 0x4F -> 30 veces - 0x55 -> 26 veces - 0x51 -> 26 veces - 0x54 -> 25 veces - -Offset 0x02200 (8704): - Valores distintos (15): 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 38 veces - 0x05 -> 24 veces - 0x0A -> 24 veces - 0x03 -> 22 veces - 0x06 -> 20 veces - -Offset 0x02201 (8705): - Valores distintos (3): 0x00, 0x40, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 185 veces - 0x40 -> 44 veces - 0x41 -> 5 veces - -Offset 0x02204 (8708): - Valores distintos (3): 0x00, 0x17, 0x1B - Clasificación: small_state - Más frecuentes: - 0x00 -> 222 veces - 0x17 -> 7 veces - 0x1B -> 5 veces - -Offset 0x02205 (8709): - Valores distintos (4): 0x00, 0x01, 0x03, 0x19 - Clasificación: small_state - Más frecuentes: - 0x00 -> 221 veces - 0x03 -> 7 veces - 0x19 -> 5 veces - 0x01 -> 1 veces - -Offset 0x02206 (8710): - Valores distintos (4): 0x00, 0x30, 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 203 veces - 0xFF -> 20 veces - 0x78 -> 9 veces - 0x30 -> 2 veces - -Offset 0x02207 (8711): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0xFF -> 20 veces - -Offset 0x02208 (8712): - Valores distintos (97): 0x05, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x27, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3F, 0x42, 0x44, 0x45, 0x46, 0x48, 0x49, 0x4B, 0x4F, 0x50, 0x53, 0x57, 0x5C, 0x5F, 0x63, 0x65, 0x68, 0x6C, 0x71, 0x72, 0x74, 0x77, 0x79, 0x7A, 0x7C, 0x7D, 0x80, 0x83, 0x87, 0x8A, 0x8C, 0x97, 0x9E, 0xA8, 0xAE, 0xB5, 0xB6, 0xB8, 0xBE, 0xC0, 0xC2, 0xCB, 0xD2, 0xDC, 0xE5, 0xE9, 0xF6 - Clasificación: bitfield_like - Más frecuentes: - 0x0F -> 14 veces - 0x15 -> 8 veces - 0x30 -> 8 veces - 0x0E -> 8 veces - 0x10 -> 7 veces - -Offset 0x02209 (8713): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x05, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 216 veces - 0x01 -> 9 veces - 0x02 -> 5 veces - 0x03 -> 2 veces - 0x16 -> 1 veces - -Offset 0x02213 (8723): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 197 veces - 0x0A -> 37 veces - -Offset 0x02214 (8724): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 197 veces - 0x07 -> 37 veces - -Offset 0x02215 (8725): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 197 veces - 0xFF -> 37 veces - -Offset 0x02220 (8736): - Valores distintos (9): 0x00, 0x03, 0x05, 0x06, 0x09, 0x0A, 0x19, 0x5C, 0xC8 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 207 veces - 0x03 -> 8 veces - 0xC8 -> 7 veces - 0x5C -> 5 veces - 0x19 -> 3 veces - -Offset 0x02222 (8738): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0x02 -> 1 veces - -Offset 0x02224 (8740): - Valores distintos (22): 0x0A, 0x1B, 0x25, 0x28, 0x39, 0x3A, 0x44, 0x5A, 0x6C, 0x75, 0x78, 0x82, 0x85, 0x8F, 0x96, 0x99, 0x9A, 0x9B, 0xA6, 0xA8, 0xBC, 0xC1 - Clasificación: bitfield_like - Más frecuentes: - 0x5A -> 122 veces - 0x99 -> 22 veces - 0xA8 -> 15 veces - 0x9A -> 10 veces - 0xA6 -> 9 veces - -Offset 0x02227 (8743): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x03 -> 177 veces - 0x07 -> 38 veces - 0x01 -> 11 veces - 0x05 -> 5 veces - 0x02 -> 2 veces - -Offset 0x02229 (8745): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 222 veces - 0x80 -> 12 veces - -Offset 0x0222A (8746): - Valores distintos (21): 0x04, 0x07, 0x0C, 0x0D, 0x1D, 0x1E, 0x21, 0x2E, 0x2F, 0x3C, 0x3D, 0x3F, 0x40, 0x49, 0x57, 0x58, 0x59, 0x5B, 0x62, 0x6B, 0xB0 - Clasificación: bitfield_like - Más frecuentes: - 0x3F -> 159 veces - 0x62 -> 15 veces - 0x40 -> 9 veces - 0x57 -> 7 veces - 0x58 -> 6 veces - -Offset 0x0222D (8749): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x80 -> 97 veces - -Offset 0x0222E (8750): - Valores distintos (23): 0x04, 0x05, 0x07, 0x08, 0x09, 0x0A, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x16, 0x1B, 0x1C, 0x27, 0x31, 0x32, 0x3E, 0x45, 0x50, 0x5D, 0x5E, 0x88 - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 131 veces - 0x0E -> 26 veces - 0x1C -> 13 veces - 0x08 -> 11 veces - 0x04 -> 7 veces - -Offset 0x02230 (8752): - Valores distintos (3): 0x00, 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x07 -> 93 veces - 0x02 -> 1 veces - -Offset 0x02231 (8753): - Valores distintos (5): 0x00, 0x02, 0x04, 0x05, 0x08 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x05 -> 57 veces - 0x04 -> 20 veces - 0x08 -> 16 veces - 0x02 -> 1 veces - -Offset 0x02232 (8754): - Valores distintos (4): 0x00, 0x03, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x06 -> 57 veces - 0x05 -> 36 veces - 0x03 -> 1 veces - -Offset 0x02233 (8755): - Valores distintos (3): 0x00, 0x01, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 156 veces - 0x06 -> 77 veces - 0x01 -> 1 veces - -Offset 0x02234 (8756): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 157 veces - 0x07 -> 77 veces - -Offset 0x02235 (8757): - Valores distintos (3): 0x00, 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 156 veces - 0x05 -> 77 veces - 0x02 -> 1 veces - -Offset 0x02236 (8758): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 233 veces - 0x01 -> 1 veces - -Offset 0x02237 (8759): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 233 veces - 0x01 -> 1 veces - -Offset 0x02270 (8816): - Valores distintos (132): 0x02, 0x04, 0x08, 0x0B, 0x0C, 0x0D, 0x0F, 0x10, 0x13, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1B, 0x1C, 0x1E, 0x21, 0x22, 0x24, 0x25, 0x26, 0x27, 0x2D, 0x33, 0x34, 0x35, 0x37, 0x3B, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x47, 0x4B, 0x4C, 0x4D, 0x4F, 0x50, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x5A, 0x5F, 0x60, 0x63, 0x64, 0x66, 0x68, 0x69, 0x6E, 0x6F, 0x70, 0x71, 0x73, 0x74, 0x79, 0x7A, 0x7D, 0x81, 0x82, 0x83, 0x85, 0x86, 0x89, 0x8A, 0x8C, 0x8D, 0x93, 0x94, 0x95, 0x99, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA2, 0xA3, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAF, 0xB0, 0xB2, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBC, 0xBD, 0xBE, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xD0, 0xD6, 0xDB, 0xDE, 0xE0, 0xE1, 0xE3, 0xE5, 0xE8, 0xED, 0xEF, 0xF0, 0xF2, 0xF3, 0xF6, 0xF7, 0xF8, 0xFA, 0xFB, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0x44 -> 7 veces - 0x5A -> 6 veces - 0xC2 -> 6 veces - 0x7D -> 5 veces - 0x3B -> 5 veces - -Offset 0x02271 (8817): - Valores distintos (97): 0x01, 0x03, 0x05, 0x0E, 0x0F, 0x11, 0x14, 0x1E, 0x1F, 0x20, 0x23, 0x24, 0x33, 0x34, 0x36, 0x3F, 0x40, 0x46, 0x47, 0x50, 0x52, 0x56, 0x59, 0x5D, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6C, 0x6E, 0x70, 0x71, 0x74, 0x77, 0x79, 0x7E, 0x87, 0x88, 0x8A, 0x8B, 0x8D, 0x8E, 0x90, 0x91, 0x92, 0x93, 0x94, 0x96, 0x9C, 0xA0, 0xA1, 0xA2, 0xA3, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB8, 0xB9, 0xBA, 0xBB, 0xBD, 0xC0, 0xC1, 0xC2, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCD, 0xCE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE4, 0xE8, 0xE9, 0xEA, 0xEC, 0xEE, 0xF2 - Clasificación: bitfield_like - Más frecuentes: - 0xAD -> 10 veces - 0xAF -> 9 veces - 0xA9 -> 7 veces - 0xAA -> 7 veces - 0x68 -> 7 veces - -Offset 0x02295 (8853): - Valores distintos (3): 0x00, 0x07, 0x09 - Clasificación: small_state - Más frecuentes: - 0x07 -> 139 veces - 0x00 -> 90 veces - 0x09 -> 5 veces - -Offset 0x02296 (8854): - Valores distintos (43): 0x01, 0x03, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x26, 0x27, 0x28, 0x2A, 0x2B, 0x2C, 0x2E, 0x31, 0x32, 0x33, 0x34 - Clasificación: bitfield_like - Más frecuentes: - 0x34 -> 16 veces - 0x19 -> 13 veces - 0x1E -> 13 veces - 0x15 -> 11 veces - 0x11 -> 10 veces - -Offset 0x02298 (8856): - Valores distintos (113): 0x00, 0x03, 0x05, 0x08, 0x0A, 0x0B, 0x0D, 0x10, 0x12, 0x13, 0x16, 0x18, 0x19, 0x1C, 0x1F, 0x22, 0x23, 0x24, 0x26, 0x27, 0x29, 0x2A, 0x2C, 0x2F, 0x31, 0x32, 0x34, 0x38, 0x3C, 0x3D, 0x3E, 0x45, 0x47, 0x4A, 0x50, 0x52, 0x53, 0x54, 0x57, 0x59, 0x5E, 0x62, 0x63, 0x65, 0x66, 0x68, 0x6A, 0x6C, 0x6E, 0x75, 0x7A, 0x7F, 0x80, 0x81, 0x83, 0x86, 0x87, 0x88, 0x8B, 0x8C, 0x8F, 0x90, 0x93, 0x94, 0x96, 0x98, 0x99, 0x9A, 0x9D, 0xA1, 0xA3, 0xA4, 0xA7, 0xA8, 0xA9, 0xAC, 0xB0, 0xB3, 0xB4, 0xB8, 0xB9, 0xBA, 0xBE, 0xBF, 0xC0, 0xC2, 0xC3, 0xC6, 0xC9, 0xCA, 0xCC, 0xCE, 0xD2, 0xD5, 0xD7, 0xD8, 0xDC, 0xE1, 0xE2, 0xE6, 0xEA, 0xEB, 0xEC, 0xF0, 0xF1, 0xF3, 0xF7, 0xF8, 0xF9, 0xFB, 0xFC, 0xFD, 0xFE - Clasificación: bitfield_like - Más frecuentes: - 0xB9 -> 10 veces - 0x2F -> 8 veces - 0x22 -> 7 veces - 0xFE -> 6 veces - 0xC3 -> 6 veces - -Offset 0x02299 (8857): - Valores distintos (100): 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0C, 0x0E, 0x0F, 0x12, 0x13, 0x16, 0x17, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x22, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x3A, 0x3C, 0x3F, 0x41, 0x42, 0x44, 0x45, 0x4B, 0x4C, 0x4D, 0x4E, 0x51, 0x55, 0x57, 0x59, 0x5A, 0x5B, 0x5C, 0x60, 0x61, 0x62, 0x66, 0x6C, 0x71, 0x74, 0x79, 0x7B, 0x7E, 0x82, 0x83, 0x85, 0x86, 0x88, 0x8D, 0x8F, 0x93, 0x99, 0x9B, 0x9F, 0xA3, 0xA4, 0xA5, 0xA7, 0xAF, 0xB1, 0xB2, 0xB4, 0xB5, 0xBA, 0xBD, 0xC1, 0xC2, 0xC7, 0xCD, 0xD2, 0xD3, 0xDE, 0xE0, 0xE4, 0xF1, 0xF4, 0xF6, 0xFA - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 13 veces - 0x32 -> 12 veces - 0x66 -> 10 veces - 0xA7 -> 7 veces - 0xCD -> 7 veces - -Offset 0x0229A (8858): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0A - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 159 veces - 0x01 -> 31 veces - 0x0A -> 19 veces - 0x02 -> 9 veces - 0x09 -> 5 veces - -Offset 0x0229C (8860): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 232 veces - 0x80 -> 2 veces - -Offset 0x0229D (8861): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 230 veces - 0x20 -> 4 veces - -Offset 0x0229E (8862): - Valores distintos (12): 0x01, 0x03, 0x06, 0x07, 0x09, 0x0A, 0x0C, 0x11, 0x12, 0x14, 0x18, 0x45 - Clasificación: bitfield_like - Más frecuentes: - 0x0A -> 56 veces - 0x18 -> 47 veces - 0x06 -> 38 veces - 0x03 -> 22 veces - 0x45 -> 15 veces - -Offset 0x0229F (8863): - Valores distintos (8): 0x00, 0x32, 0x33, 0x36, 0x37, 0x3A, 0x3D, 0x41 - Clasificación: small_state - Más frecuentes: - 0x37 -> 52 veces - 0x36 -> 47 veces - 0x3D -> 41 veces - 0x41 -> 33 veces - 0x33 -> 30 veces - -Offset 0x022A0 (8864): - Valores distintos (7): 0x00, 0x21, 0x23, 0x26, 0x27, 0x2A, 0x31 - Clasificación: small_state - Más frecuentes: - 0x2A -> 59 veces - 0x26 -> 52 veces - 0x27 -> 47 veces - 0x31 -> 33 veces - 0x23 -> 32 veces - -Offset 0x022A1 (8865): - Valores distintos (9): 0x00, 0x01, 0x02, 0x08, 0x0A, 0x0C, 0x10, 0x12, 0x1F - Clasificación: bitfield_like - Más frecuentes: - 0x08 -> 48 veces - 0x1F -> 47 veces - 0x12 -> 45 veces - 0x10 -> 35 veces - 0x02 -> 32 veces - -Offset 0x022A2 (8866): - Valores distintos (7): 0x00, 0x05, 0x09, 0x0B, 0x0E, 0x12, 0x18 - Clasificación: small_state - Más frecuentes: - 0x12 -> 58 veces - 0x05 -> 48 veces - 0x0B -> 44 veces - 0x09 -> 31 veces - 0x00 -> 22 veces - -Offset 0x022A3 (8867): - Valores distintos (4): 0x00, 0x0A, 0x10, 0x13 - Clasificación: small_state - Más frecuentes: - 0x13 -> 168 veces - 0x00 -> 43 veces - 0x0A -> 13 veces - 0x10 -> 10 veces - -Offset 0x022A4 (8868): - Valores distintos (90): 0x01, 0x02, 0x04, 0x0C, 0x0D, 0x0F, 0x14, 0x15, 0x17, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x22, 0x25, 0x26, 0x28, 0x29, 0x2B, 0x2D, 0x2F, 0x32, 0x33, 0x34, 0x38, 0x3B, 0x3C, 0x3F, 0x42, 0x44, 0x45, 0x4A, 0x4E, 0x51, 0x52, 0x53, 0x54, 0x56, 0x5C, 0x5F, 0x60, 0x62, 0x65, 0x6A, 0x71, 0x72, 0x74, 0x75, 0x78, 0x7A, 0x7D, 0x7F, 0x80, 0x82, 0x86, 0x89, 0x8F, 0x93, 0x94, 0x98, 0x9A, 0x9D, 0x9F, 0xA0, 0xA5, 0xA7, 0xAD, 0xB0, 0xB7, 0xB8, 0xBF, 0xC0, 0xC2, 0xC7, 0xC8, 0xCA, 0xCE, 0xD2, 0xD5, 0xDA, 0xDD, 0xE1, 0xE7, 0xEA, 0xED, 0xEF, 0xF2, 0xF5, 0xF9 - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 24 veces - 0xD2 -> 13 veces - 0x86 -> 10 veces - 0xA5 -> 9 veces - 0xE1 -> 9 veces - -Offset 0x022A5 (8869): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 207 veces - 0x01 -> 27 veces - -Offset 0x022A6 (8870): - Valores distintos (61): 0x01, 0x03, 0x09, 0x0B, 0x0C, 0x0D, 0x0F, 0x10, 0x11, 0x15, 0x16, 0x17, 0x18, 0x1B, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x27, 0x29, 0x2A, 0x2B, 0x2D, 0x2E, 0x2F, 0x30, 0x35, 0x37, 0x39, 0x3A, 0x3B, 0x3E, 0x3F, 0x43, 0x46, 0x4A, 0x4C, 0x4E, 0x57, 0x5E, 0x66, 0x6C, 0x76, 0x7A, 0x88, 0x8F, 0x92, 0xA0, 0xA4, 0xA5, 0xAD, 0xB4, 0xB7, 0xB9, 0xBD, 0xC1, 0xC4 - Clasificación: bitfield_like - Más frecuentes: - 0x4E -> 14 veces - 0x43 -> 13 veces - 0xC4 -> 12 veces - 0x2F -> 10 veces - 0x37 -> 10 veces - -Offset 0x022A8 (8872): - Valores distintos (2): 0x01, 0x0B - Clasificación: small_state - Más frecuentes: - 0x01 -> 185 veces - 0x0B -> 49 veces - -Offset 0x022A9 (8873): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 233 veces - 0x01 -> 1 veces - -Offset 0x022AA (8874): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 225 veces - 0x01 -> 9 veces - -Offset 0x022AB (8875): - Valores distintos (5): 0x00, 0x01, 0x09, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 129 veces - 0x09 -> 79 veces - 0xFF -> 13 veces - 0x01 -> 7 veces - 0x10 -> 6 veces - -Offset 0x022AC (8876): - Valores distintos (41): 0x02, 0x04, 0x14, 0x19, 0x25, 0x29, 0x2D, 0x32, 0x3A, 0x3E, 0x46, 0x4A, 0x51, 0x57, 0x60, 0x67, 0x71, 0x80, 0x86, 0x8F, 0x98, 0x9F, 0xA5, 0xAC, 0xB0, 0xB7, 0xBF, 0xC8, 0xCA, 0xD2, 0xD5, 0xDA, 0xDD, 0xE1, 0xE7, 0xEA, 0xED, 0xEF, 0xF2, 0xF5, 0xF9 - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 26 veces - 0xA5 -> 18 veces - 0xD2 -> 13 veces - 0xE1 -> 12 veces - 0x86 -> 11 veces - -Offset 0x022AD (8877): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 207 veces - 0x01 -> 27 veces - -Offset 0x022AE (8878): - Valores distintos (40): 0x0B, 0x0C, 0x14, 0x18, 0x1D, 0x21, 0x24, 0x25, 0x26, 0x2B, 0x2E, 0x2F, 0x30, 0x35, 0x37, 0x3A, 0x3B, 0x3F, 0x43, 0x46, 0x4A, 0x4C, 0x4E, 0x57, 0x5E, 0x66, 0x6C, 0x76, 0x7A, 0x88, 0x8F, 0x92, 0xA0, 0xA5, 0xAD, 0xB4, 0xBD, 0xBF, 0xC1, 0xC4 - Clasificación: bitfield_like - Más frecuentes: - 0x43 -> 16 veces - 0xC4 -> 16 veces - 0x2E -> 15 veces - 0x4E -> 13 veces - 0x37 -> 11 veces - -Offset 0x022B0 (8880): - Valores distintos (48): 0x00, 0x0E, 0x10, 0x13, 0x14, 0x18, 0x19, 0x1B, 0x1C, 0x1E, 0x25, 0x2B, 0x2F, 0x34, 0x37, 0x3C, 0x4B, 0x4F, 0x55, 0x57, 0x5A, 0x5C, 0x60, 0x68, 0x69, 0x6D, 0x71, 0x75, 0x76, 0x79, 0x7A, 0x7C, 0x7D, 0x82, 0x87, 0x91, 0x98, 0x9C, 0xA4, 0xAA, 0xB0, 0xB6, 0xBD, 0xC4, 0xCF, 0xD5, 0xF0, 0xF9 - Clasificación: bitfield_like - Más frecuentes: - 0x7D -> 16 veces - 0x9C -> 13 veces - 0xBD -> 13 veces - 0x55 -> 10 veces - 0x68 -> 10 veces - -Offset 0x022B1 (8881): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 165 veces - 0x01 -> 69 veces - -Offset 0x022B2 (8882): - Valores distintos (41): 0x0C, 0x0D, 0x14, 0x18, 0x1B, 0x1D, 0x1F, 0x23, 0x26, 0x29, 0x2A, 0x2F, 0x32, 0x3F, 0x4A, 0x4F, 0x52, 0x56, 0x5D, 0x61, 0x66, 0x69, 0x6B, 0x76, 0x77, 0x82, 0x85, 0x86, 0x89, 0x8A, 0x8D, 0x90, 0x98, 0x9C, 0xBA, 0xBF, 0xC0, 0xE3, 0xF8, 0xFA, 0xFC - Clasificación: bitfield_like - Más frecuentes: - 0xFC -> 27 veces - 0xBA -> 18 veces - 0xBF -> 14 veces - 0xE3 -> 14 veces - 0x89 -> 13 veces - -Offset 0x022B4 (8884): - Valores distintos (31): 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0B, 0x0D, 0x0E, 0x0F, 0x11, 0x14, 0x16, 0x19, 0x1B, 0x1D, 0x1F, 0x22, 0x24, 0x25, 0x27, 0x28, 0x2B, 0x2D, 0x2E, 0x30, 0x34, 0x3C, 0x3E, 0x41, 0x42 - Clasificación: bitfield_like - Más frecuentes: - 0x0F -> 27 veces - 0x16 -> 19 veces - 0x42 -> 16 veces - 0x1B -> 15 veces - 0x11 -> 13 veces - -Offset 0x022B6 (8886): - Valores distintos (33): 0x0A, 0x0D, 0x13, 0x16, 0x1B, 0x21, 0x22, 0x24, 0x25, 0x27, 0x2A, 0x2C, 0x2D, 0x2E, 0x2F, 0x31, 0x32, 0x37, 0x3E, 0x45, 0x4B, 0x4E, 0x56, 0x60, 0x69, 0x70, 0x7C, 0x80, 0x87, 0x8C, 0x94, 0x97, 0x9D - Clasificación: bitfield_like - Más frecuentes: - 0x27 -> 37 veces - 0x2E -> 16 veces - 0x9D -> 16 veces - 0x2A -> 15 veces - 0x31 -> 13 veces - -Offset 0x022BA (8890): - Valores distintos (2): 0x01, 0x0B - Clasificación: small_state - Más frecuentes: - 0x01 -> 186 veces - 0x0B -> 48 veces - -Offset 0x022BB (8891): - Valores distintos (3): 0x02, 0x04, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 142 veces - 0x07 -> 77 veces - 0x04 -> 15 veces - -Offset 0x022BC (8892): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 221 veces - 0x07 -> 13 veces - -Offset 0x022C2 (8898): - Valores distintos (2): 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x02 -> 224 veces - 0x05 -> 10 veces - -Offset 0x022C3 (8899): - Valores distintos (2): 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x02 -> 221 veces - 0x05 -> 13 veces - -Offset 0x022C4 (8900): - Valores distintos (4): 0x32, 0x37, 0x46, 0x4B - Clasificación: small_state - Más frecuentes: - 0x37 -> 112 veces - 0x32 -> 64 veces - 0x4B -> 34 veces - 0x46 -> 24 veces - -Offset 0x022C7 (8903): - Valores distintos (4): 0x04, 0x06, 0x08, 0x12 - Clasificación: small_state - Más frecuentes: - 0x08 -> 133 veces - 0x06 -> 88 veces - 0x04 -> 7 veces - 0x12 -> 6 veces - -Offset 0x022C8 (8904): - Valores distintos (2): 0x5F, 0x64 - Clasificación: small_state - Más frecuentes: - 0x64 -> 181 veces - 0x5F -> 53 veces - -Offset 0x022CC (8908): - Valores distintos (39): 0x02, 0x04, 0x14, 0x19, 0x25, 0x29, 0x2D, 0x32, 0x3A, 0x3E, 0x46, 0x4A, 0x51, 0x57, 0x60, 0x67, 0x71, 0x80, 0x86, 0x8F, 0x98, 0x9F, 0xA5, 0xB0, 0xB7, 0xBF, 0xC8, 0xD2, 0xD5, 0xDA, 0xDD, 0xE1, 0xE7, 0xEA, 0xED, 0xEF, 0xF2, 0xF5, 0xF9 - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 26 veces - 0xE1 -> 15 veces - 0xA5 -> 13 veces - 0xD2 -> 13 veces - 0x86 -> 11 veces - -Offset 0x022CD (8909): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 207 veces - 0x01 -> 27 veces - -Offset 0x022CE (8910): - Valores distintos (40): 0x0B, 0x0C, 0x14, 0x18, 0x1D, 0x21, 0x24, 0x25, 0x26, 0x2B, 0x2E, 0x2F, 0x30, 0x35, 0x37, 0x3A, 0x3B, 0x3F, 0x43, 0x46, 0x4A, 0x4C, 0x4E, 0x57, 0x5E, 0x66, 0x6C, 0x76, 0x7A, 0x88, 0x8F, 0x92, 0xA0, 0xA5, 0xAD, 0xB4, 0xBD, 0xBF, 0xC1, 0xC4 - Clasificación: bitfield_like - Más frecuentes: - 0x43 -> 16 veces - 0xC4 -> 16 veces - 0x2E -> 15 veces - 0x4E -> 13 veces - 0x37 -> 11 veces - -Offset 0x022D0 (8912): - Valores distintos (42): 0x0C, 0x0E, 0x12, 0x15, 0x16, 0x18, 0x1D, 0x23, 0x27, 0x2C, 0x2F, 0x34, 0x38, 0x3E, 0x43, 0x51, 0x56, 0x5C, 0x61, 0x68, 0x6C, 0x74, 0x7A, 0x80, 0x86, 0x8D, 0x94, 0x9A, 0x9E, 0xA5, 0xAA, 0xB0, 0xB9, 0xBE, 0xC2, 0xCB, 0xCF, 0xD3, 0xD7, 0xDB, 0xDC, 0xDF - Clasificación: bitfield_like - Más frecuentes: - 0xDF -> 16 veces - 0x6C -> 13 veces - 0x8D -> 13 veces - 0x56 -> 11 veces - 0x3E -> 10 veces - -Offset 0x022D2 (8914): - Valores distintos (29): 0x0A, 0x0B, 0x10, 0x11, 0x13, 0x15, 0x19, 0x1C, 0x1F, 0x20, 0x25, 0x28, 0x2D, 0x30, 0x34, 0x3B, 0x3F, 0x42, 0x47, 0x48, 0x4C, 0x50, 0x53, 0x57, 0x5B, 0x5F, 0x60, 0x62, 0x64 - Clasificación: bitfield_like - Más frecuentes: - 0x5F -> 38 veces - 0x60 -> 31 veces - 0x64 -> 27 veces - 0x4C -> 13 veces - 0x3F -> 11 veces - -Offset 0x022D4 (8916): - Valores distintos (33): 0x08, 0x0A, 0x0B, 0x0D, 0x0F, 0x10, 0x11, 0x13, 0x16, 0x18, 0x1A, 0x1D, 0x1F, 0x21, 0x24, 0x26, 0x28, 0x2A, 0x2B, 0x2E, 0x31, 0x33, 0x38, 0x39, 0x3C, 0x3F, 0x42, 0x45, 0x49, 0x51, 0x53, 0x56, 0x57 - Clasificación: bitfield_like - Más frecuentes: - 0x26 -> 22 veces - 0x1A -> 21 veces - 0x18 -> 18 veces - 0x21 -> 18 veces - 0x57 -> 16 veces - -Offset 0x022D6 (8918): - Valores distintos (33): 0x0A, 0x0D, 0x13, 0x16, 0x1B, 0x21, 0x22, 0x24, 0x25, 0x27, 0x2A, 0x2C, 0x2D, 0x2E, 0x2F, 0x31, 0x32, 0x37, 0x3E, 0x45, 0x4B, 0x4E, 0x56, 0x60, 0x69, 0x70, 0x7C, 0x80, 0x87, 0x8C, 0x94, 0x97, 0x9D - Clasificación: bitfield_like - Más frecuentes: - 0x27 -> 37 veces - 0x2E -> 16 veces - 0x9D -> 16 veces - 0x2A -> 15 veces - 0x31 -> 13 veces - -Offset 0x022E4 (8932): - Valores distintos (2): 0x32, 0x37 - Clasificación: small_state - Más frecuentes: - 0x37 -> 139 veces - 0x32 -> 95 veces - -Offset 0x022E7 (8935): - Valores distintos (2): 0x06, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 139 veces - 0x06 -> 95 veces - -Offset 0x022E8 (8936): - Valores distintos (2): 0x5F, 0x64 - Clasificación: small_state - Más frecuentes: - 0x64 -> 139 veces - 0x5F -> 95 veces - -Offset 0x022ED (8941): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x4B -> 227 veces - 0x00 -> 7 veces - -Offset 0x022EE (8942): - Valores distintos (2): 0x00, 0x47 - Clasificación: small_state - Más frecuentes: - 0x47 -> 214 veces - 0x00 -> 20 veces - -Offset 0x022EF (8943): - Valores distintos (2): 0x00, 0x4C - Clasificación: small_state - Más frecuentes: - 0x4C -> 164 veces - 0x00 -> 70 veces - -Offset 0x022F0 (8944): - Valores distintos (2): 0x00, 0x73 - Clasificación: small_state - Más frecuentes: - 0x73 -> 164 veces - 0x00 -> 70 veces - -Offset 0x022F1 (8945): - Valores distintos (2): 0x00, 0x49 - Clasificación: small_state - Más frecuentes: - 0x49 -> 139 veces - 0x00 -> 95 veces - -Offset 0x022F2 (8946): - Valores distintos (2): 0x00, 0x48 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x48 -> 107 veces - -Offset 0x022F3 (8947): - Valores distintos (2): 0x00, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x4D -> 85 veces - -Offset 0x022F4 (8948): - Valores distintos (2): 0x00, 0x4A - Clasificación: small_state - Más frecuentes: - 0x00 -> 165 veces - 0x4A -> 69 veces - -Offset 0x022F6 (8950): - Valores distintos (2): 0x00, 0x52 - Clasificación: small_state - Más frecuentes: - 0x52 -> 227 veces - 0x00 -> 7 veces - -Offset 0x022F7 (8951): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x53 -> 191 veces - 0x00 -> 43 veces - -Offset 0x022F8 (8952): - Valores distintos (2): 0x00, 0x56 - Clasificación: small_state - Más frecuentes: - 0x56 -> 121 veces - 0x00 -> 113 veces - -Offset 0x02300 (8960): - Valores distintos (2): 0x00, 0x97 - Clasificación: small_state - Más frecuentes: - 0x97 -> 192 veces - 0x00 -> 42 veces - -Offset 0x02301 (8961): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x15 -> 54 veces - -Offset 0x0230A (8970): - Valores distintos (2): 0x00, 0x77 - Clasificación: small_state - Más frecuentes: - 0x77 -> 214 veces - 0x00 -> 20 veces - -Offset 0x0230B (8971): - Valores distintos (2): 0x00, 0xAA - Clasificación: small_state - Más frecuentes: - 0xAA -> 184 veces - 0x00 -> 50 veces - -Offset 0x0230C (8972): - Valores distintos (2): 0x00, 0x27 - Clasificación: small_state - Más frecuentes: - 0x27 -> 201 veces - 0x00 -> 33 veces - -Offset 0x0230D (8973): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 163 veces - 0x00 -> 71 veces - -Offset 0x0230E (8974): - Valores distintos (2): 0x00, 0x14 - Clasificación: small_state - Más frecuentes: - 0x14 -> 140 veces - 0x00 -> 94 veces - -Offset 0x0230F (8975): - Valores distintos (3): 0x00, 0x45, 0xC3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0xC3 -> 75 veces - 0x45 -> 43 veces - -Offset 0x02310 (8976): - Valores distintos (2): 0x00, 0xC6 - Clasificación: small_state - Más frecuentes: - 0x00 -> 182 veces - 0xC6 -> 52 veces - -Offset 0x02311 (8977): - Valores distintos (2): 0x00, 0xC9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0xC9 -> 43 veces - -Offset 0x02312 (8978): - Valores distintos (2): 0x00, 0xCE - Clasificación: small_state - Más frecuentes: - 0x00 -> 199 veces - 0xCE -> 35 veces - -Offset 0x02313 (8979): - Valores distintos (2): 0x00, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 228 veces - 0x3E -> 6 veces - -Offset 0x02314 (8980): - Valores distintos (6): 0x00, 0x07, 0x09, 0x1E, 0x2D, 0x33 - Clasificación: small_state - Más frecuentes: - 0x09 -> 129 veces - 0x1E -> 56 veces - 0x33 -> 23 veces - 0x00 -> 13 veces - 0x07 -> 7 veces - -Offset 0x02315 (8981): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 129 veces - 0xFD -> 79 veces - 0x00 -> 20 veces - 0xFF -> 6 veces - -Offset 0x02316 (8982): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 129 veces - 0x03 -> 79 veces - 0x00 -> 19 veces - 0x01 -> 7 veces - -Offset 0x02317 (8983): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 129 veces - 0x01 -> 79 veces - 0x00 -> 13 veces - 0xFF -> 13 veces - -Offset 0x02318 (8984): - Valores distintos (4): 0x00, 0x01, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 129 veces - 0xFD -> 79 veces - 0x00 -> 13 veces - 0xFF -> 13 veces - -Offset 0x02319 (8985): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x01 -> 79 veces - 0x02 -> 6 veces - -Offset 0x0231A (8986): - Valores distintos (4): 0x00, 0x02, 0x03, 0xFD - Clasificación: small_state - Más frecuentes: - 0xFD -> 129 veces - 0x03 -> 79 veces - 0x00 -> 19 veces - 0x02 -> 7 veces - -Offset 0x02339 (9017): - Valores distintos (2): 0x01, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 139 veces - 0x01 -> 95 veces - -Offset 0x0233A (9018): - Valores distintos (25): 0x05, 0x09, 0x0A, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1C, 0x1D, 0x1E, 0x1F, 0x23, 0x26, 0x28 - Clasificación: bitfield_like - Más frecuentes: - 0x05 -> 42 veces - 0x10 -> 28 veces - 0x1A -> 25 veces - 0x28 -> 24 veces - 0x0F -> 18 veces - -Offset 0x0233B (9019): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 186 veces - 0x00 -> 48 veces - -Offset 0x0233C (9020): - Valores distintos (55): 0x01, 0x06, 0x0A, 0x0F, 0x10, 0x11, 0x17, 0x1C, 0x23, 0x28, 0x2B, 0x3F, 0x41, 0x42, 0x43, 0x4A, 0x54, 0x55, 0x5A, 0x5B, 0x6D, 0x71, 0x75, 0x77, 0x78, 0x79, 0x89, 0x8C, 0x92, 0x95, 0x9F, 0xA1, 0xA3, 0xA6, 0xA7, 0xAF, 0xB8, 0xB9, 0xBD, 0xBF, 0xCB, 0xD3, 0xDA, 0xE0, 0xE1, 0xE4, 0xEB, 0xED, 0xF0, 0xF2, 0xF4, 0xF7, 0xF9, 0xFA, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0x5A -> 44 veces - 0x0F -> 28 veces - 0x92 -> 24 veces - 0x6D -> 13 veces - 0xBD -> 12 veces - -Offset 0x0233D (9021): - Valores distintos (46): 0x00, 0x02, 0x03, 0x06, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x12, 0x13, 0x16, 0x1A, 0x1D, 0x1F, 0x21, 0x26, 0x27, 0x2E, 0x37, 0x38, 0x39, 0x3B, 0x3C, 0x46, 0x4C, 0x4D, 0x56, 0x59, 0x61, 0x62, 0x63, 0x67, 0x6A, 0x6F, 0x8C, 0x94, 0x98, 0x9A, 0xB0, 0xD6, 0xD8, 0xDA - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 42 veces - 0x98 -> 24 veces - 0x6F -> 22 veces - 0x13 -> 16 veces - 0x4D -> 16 veces - -Offset 0x0233E (9022): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 199 veces - 0x02 -> 24 veces - 0x01 -> 11 veces - -Offset 0x02341 (9025): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0x20 -> 9 veces - -Offset 0x02342 (9026): - Valores distintos (5): 0x1E, 0x20, 0x21, 0x26, 0x28 - Clasificación: small_state - Más frecuentes: - 0x26 -> 77 veces - 0x1E -> 42 veces - 0x28 -> 40 veces - 0x20 -> 38 veces - 0x21 -> 37 veces - -Offset 0x02343 (9027): - Valores distintos (5): 0x00, 0x32, 0x36, 0x38, 0x3C - Clasificación: small_state - Más frecuentes: - 0x38 -> 70 veces - 0x3C -> 43 veces - 0x00 -> 42 veces - 0x36 -> 41 veces - 0x32 -> 38 veces - -Offset 0x02344 (9028): - Valores distintos (5): 0x00, 0x26, 0x28, 0x29, 0x2C - Clasificación: small_state - Más frecuentes: - 0x28 -> 77 veces - 0x26 -> 59 veces - 0x00 -> 42 veces - 0x2C -> 40 veces - 0x29 -> 16 veces - -Offset 0x02345 (9029): - Valores distintos (5): 0x05, 0x06, 0x0B, 0x12, 0x16 - Clasificación: small_state - Más frecuentes: - 0x0B -> 55 veces - 0x12 -> 49 veces - 0x06 -> 44 veces - 0x05 -> 43 veces - 0x16 -> 43 veces - -Offset 0x02346 (9030): - Valores distintos (5): 0x00, 0x08, 0x10, 0x14, 0x18 - Clasificación: small_state - Más frecuentes: - 0x10 -> 98 veces - 0x00 -> 84 veces - 0x18 -> 46 veces - 0x14 -> 3 veces - 0x08 -> 3 veces - -Offset 0x02347 (9031): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 126 veces - 0x02 -> 108 veces - -Offset 0x02348 (9032): - Valores distintos (41): 0x01, 0x02, 0x03, 0x0E, 0x0F, 0x15, 0x16, 0x1A, 0x1B, 0x1C, 0x1D, 0x1F, 0x22, 0x2D, 0x30, 0x33, 0x34, 0x35, 0x39, 0x3A, 0x3B, 0x3F, 0x42, 0x46, 0x4D, 0x4F, 0x50, 0x55, 0x56, 0x58, 0x5A, 0x5C, 0x60, 0x62, 0x6C, 0x72, 0x76, 0x7C, 0x9D, 0xB4, 0xC0 - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 44 veces - 0x42 -> 26 veces - 0xC0 -> 24 veces - 0x62 -> 22 veces - 0x3F -> 12 veces - -Offset 0x0234A (9034): - Valores distintos (30): 0x08, 0x1E, 0x21, 0x30, 0x35, 0x38, 0x3D, 0x42, 0x43, 0x45, 0x47, 0x4D, 0x52, 0x57, 0x5A, 0x5C, 0x5F, 0x67, 0x6E, 0x78, 0x7E, 0x83, 0x8C, 0x97, 0xA2, 0xB6, 0xBD, 0xC6, 0xD1, 0xF1 - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 42 veces - 0x57 -> 29 veces - 0xA2 -> 25 veces - 0x1E -> 24 veces - 0x52 -> 17 veces - -Offset 0x0234B (9035): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 205 veces - 0x01 -> 29 veces - -Offset 0x0234C (9036): - Valores distintos (2): 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 222 veces - 0x01 -> 12 veces - -Offset 0x0234E (9038): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 222 veces - 0x01 -> 9 veces - 0x02 -> 1 veces - 0x04 -> 1 veces - 0x05 -> 1 veces - -Offset 0x0234F (9039): - Valores distintos (5): 0x05, 0x06, 0x07, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 54 veces - 0x05 -> 53 veces - 0x08 -> 46 veces - 0xFF -> 42 veces - 0x06 -> 39 veces - -Offset 0x02350 (9040): - Valores distintos (27): 0x1B, 0x24, 0x29, 0x2C, 0x2D, 0x35, 0x39, 0x3A, 0x3B, 0x3F, 0x40, 0x42, 0x4D, 0x50, 0x55, 0x58, 0x5A, 0x5C, 0x60, 0x62, 0x6C, 0x72, 0x76, 0x7C, 0x9D, 0xB4, 0xC0 - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 42 veces - 0x42 -> 28 veces - 0xC0 -> 24 veces - 0x62 -> 22 veces - 0x3F -> 15 veces - -Offset 0x02352 (9042): - Valores distintos (25): 0x08, 0x1E, 0x21, 0x34, 0x38, 0x42, 0x45, 0x4D, 0x52, 0x57, 0x5C, 0x63, 0x67, 0x6E, 0x78, 0x7E, 0x83, 0x8C, 0x97, 0xA2, 0xB6, 0xBD, 0xC6, 0xD1, 0xF1 - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 42 veces - 0x57 -> 28 veces - 0xA2 -> 25 veces - 0x1E -> 24 veces - 0x52 -> 18 veces - -Offset 0x02353 (9043): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 205 veces - 0x01 -> 29 veces - -Offset 0x02354 (9044): - Valores distintos (17): 0x13, 0x28, 0x2B, 0x30, 0x33, 0x35, 0x3D, 0x3F, 0x68, 0x69, 0x6A, 0x6B, 0x71, 0x72, 0x82, 0x86, 0x87 - Clasificación: bitfield_like - Más frecuentes: - 0x13 -> 42 veces - 0x6B -> 42 veces - 0x87 -> 29 veces - 0x3F -> 26 veces - 0x33 -> 21 veces - -Offset 0x02356 (9046): - Valores distintos (27): 0x13, 0x24, 0x29, 0x2A, 0x2C, 0x2F, 0x30, 0x3B, 0x45, 0x48, 0x50, 0x51, 0x53, 0x54, 0x5D, 0x60, 0x61, 0x63, 0x65, 0x7B, 0x7C, 0x80, 0x8C, 0x8F, 0x91, 0x94, 0x96 - Clasificación: bitfield_like - Más frecuentes: - 0x13 -> 42 veces - 0x96 -> 29 veces - 0x7C -> 25 veces - 0x50 -> 16 veces - 0x7B -> 16 veces - -Offset 0x02358 (9048): - Valores distintos (17): 0x09, 0x0C, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x17, 0x1A, 0x1B, 0x21, 0x24, 0x26, 0x27 - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 42 veces - 0x14 -> 31 veces - 0x17 -> 30 veces - 0x11 -> 25 veces - 0x27 -> 24 veces - -Offset 0x0235A (9050): - Valores distintos (25): 0x18, 0x28, 0x2C, 0x32, 0x36, 0x38, 0x39, 0x3D, 0x42, 0x45, 0x4C, 0x50, 0x57, 0x59, 0x5E, 0x5F, 0x69, 0x6F, 0x86, 0x8D, 0xA1, 0xA5, 0xB0, 0xBA, 0xBF - Clasificación: bitfield_like - Más frecuentes: - 0x18 -> 42 veces - 0x3D -> 28 veces - 0x6F -> 25 veces - 0xBF -> 24 veces - 0x32 -> 18 veces - -Offset 0x0235C (9052): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 157 veces - 0x01 -> 77 veces - -Offset 0x02364 (9060): - Valores distintos (2): 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x05 -> 180 veces - 0x06 -> 54 veces - -Offset 0x02366 (9062): - Valores distintos (3): 0x02, 0x03, 0x05 - Clasificación: small_state - Más frecuentes: - 0x05 -> 98 veces - 0x02 -> 96 veces - 0x03 -> 40 veces - -Offset 0x02367 (9063): - Valores distintos (3): 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x02 -> 140 veces - 0x04 -> 54 veces - 0x03 -> 40 veces - -Offset 0x0236B (9067): - Valores distintos (2): 0x0A, 0x0C - Clasificación: small_state - Más frecuentes: - 0x0C -> 138 veces - 0x0A -> 96 veces - -Offset 0x02370 (9072): - Valores distintos (24): 0x1B, 0x29, 0x2D, 0x35, 0x3A, 0x3B, 0x3F, 0x42, 0x47, 0x49, 0x4D, 0x50, 0x55, 0x5A, 0x5C, 0x60, 0x62, 0x6C, 0x72, 0x76, 0x7C, 0x9D, 0xB4, 0xC0 - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 42 veces - 0x42 -> 28 veces - 0x62 -> 25 veces - 0xC0 -> 24 veces - 0x3F -> 18 veces - -Offset 0x02372 (9074): - Valores distintos (25): 0x08, 0x1E, 0x21, 0x34, 0x38, 0x42, 0x45, 0x4D, 0x52, 0x57, 0x5C, 0x63, 0x67, 0x6E, 0x78, 0x7E, 0x83, 0x8C, 0x97, 0xA2, 0xB6, 0xBD, 0xC6, 0xD1, 0xF1 - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 42 veces - 0x57 -> 28 veces - 0xA2 -> 25 veces - 0x1E -> 24 veces - 0x52 -> 18 veces - -Offset 0x02373 (9075): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 205 veces - 0x01 -> 29 veces - -Offset 0x02374 (9076): - Valores distintos (14): 0x0D, 0x14, 0x17, 0x1C, 0x1F, 0x21, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x2C, 0x2D - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 42 veces - 0x26 -> 42 veces - 0x23 -> 33 veces - 0x2D -> 29 veces - 0x1F -> 21 veces - -Offset 0x02376 (9078): - Valores distintos (21): 0x0D, 0x12, 0x14, 0x15, 0x17, 0x1A, 0x1B, 0x1E, 0x20, 0x21, 0x24, 0x25, 0x27, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2F, 0x32, 0x34 - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 42 veces - 0x34 -> 29 veces - 0x1E -> 28 veces - 0x2B -> 25 veces - 0x2A -> 24 veces - -Offset 0x02378 (9080): - Valores distintos (19): 0x0E, 0x13, 0x14, 0x15, 0x17, 0x1A, 0x1C, 0x1D, 0x1F, 0x20, 0x21, 0x24, 0x26, 0x28, 0x29, 0x2B, 0x2E, 0x30, 0x31 - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 42 veces - 0x26 -> 30 veces - 0x1C -> 28 veces - 0x31 -> 24 veces - 0x17 -> 21 veces - -Offset 0x0237A (9082): - Valores distintos (24): 0x18, 0x25, 0x29, 0x2F, 0x35, 0x36, 0x3D, 0x42, 0x45, 0x4C, 0x50, 0x57, 0x59, 0x5E, 0x5F, 0x69, 0x6F, 0x81, 0x88, 0x92, 0x96, 0xA1, 0xAB, 0xB0 - Clasificación: bitfield_like - Más frecuentes: - 0x18 -> 42 veces - 0x3D -> 28 veces - 0x6F -> 25 veces - 0xB0 -> 24 veces - 0x2F -> 18 veces - -Offset 0x0238B (9099): - Valores distintos (2): 0x0A, 0x0C - Clasificación: small_state - Más frecuentes: - 0x0C -> 139 veces - 0x0A -> 95 veces - -Offset 0x02390 (9104): - Valores distintos (2): 0x00, 0x4F - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x4F -> 114 veces - -Offset 0x02391 (9105): - Valores distintos (2): 0x00, 0x4E - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x4E -> 92 veces - -Offset 0x0239A (9114): - Valores distintos (2): 0x00, 0x59 - Clasificación: small_state - Más frecuentes: - 0x59 -> 192 veces - 0x00 -> 42 veces - -Offset 0x0239B (9115): - Valores distintos (2): 0x00, 0x5A - Clasificación: small_state - Más frecuentes: - 0x5A -> 191 veces - 0x00 -> 43 veces - -Offset 0x0239C (9116): - Valores distintos (2): 0x00, 0x58 - Clasificación: small_state - Más frecuentes: - 0x58 -> 182 veces - 0x00 -> 52 veces - -Offset 0x023A7 (9127): - Valores distintos (2): 0x00, 0x67 - Clasificación: small_state - Más frecuentes: - 0x67 -> 192 veces - 0x00 -> 42 veces - -Offset 0x023A8 (9128): - Valores distintos (2): 0x00, 0x5F - Clasificación: small_state - Más frecuentes: - 0x5F -> 188 veces - 0x00 -> 46 veces - -Offset 0x023A9 (9129): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x65 -> 161 veces - 0x00 -> 73 veces - -Offset 0x023AA (9130): - Valores distintos (2): 0x00, 0x62 - Clasificación: small_state - Más frecuentes: - 0x62 -> 143 veces - 0x00 -> 91 veces - -Offset 0x023AB (9131): - Valores distintos (2): 0x00, 0x60 - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0x60 -> 43 veces - -Offset 0x023AC (9132): - Valores distintos (2): 0x00, 0x68 - Clasificación: small_state - Más frecuentes: - 0x00 -> 199 veces - 0x68 -> 35 veces - -Offset 0x023AD (9133): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 205 veces - 0x63 -> 29 veces - -Offset 0x023AE (9134): - Valores distintos (3): 0x00, 0x0A, 0x29 - Clasificación: small_state - Más frecuentes: - 0x0A -> 140 veces - 0x00 -> 71 veces - 0x29 -> 23 veces - -Offset 0x023AF (9135): - Valores distintos (3): 0x00, 0x3F, 0xA4 - Clasificación: small_state - Más frecuentes: - 0xA4 -> 140 veces - 0x00 -> 71 veces - 0x3F -> 23 veces - -Offset 0x023B0 (9136): - Valores distintos (2): 0x00, 0xA5 - Clasificación: small_state - Más frecuentes: - 0xA5 -> 163 veces - 0x00 -> 71 veces - -Offset 0x023B1 (9137): - Valores distintos (2): 0x00, 0xB3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0xB3 -> 107 veces - -Offset 0x023B2 (9138): - Valores distintos (2): 0x00, 0xCF - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0xCF -> 99 veces - -Offset 0x023B3 (9139): - Valores distintos (2): 0x00, 0xA9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0xA9 -> 85 veces - -Offset 0x023B4 (9140): - Valores distintos (2): 0x00, 0xBC - Clasificación: small_state - Más frecuentes: - 0x00 -> 169 veces - 0xBC -> 65 veces - -Offset 0x023B5 (9141): - Valores distintos (2): 0x00, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x06 -> 40 veces - -Offset 0x023B6 (9142): - Valores distintos (2): 0x00, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x28 -> 40 veces - -Offset 0x023B7 (9143): - Valores distintos (2): 0x00, 0x8C - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x8C -> 25 veces - -Offset 0x023B8 (9144): - Valores distintos (5): 0x00, 0x08, 0x10, 0x18, 0x1E - Clasificación: small_state - Más frecuentes: - 0x10 -> 54 veces - 0x08 -> 53 veces - 0x18 -> 46 veces - 0x00 -> 42 veces - 0x1E -> 39 veces - -Offset 0x023B9 (9145): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 195 veces - 0x04 -> 39 veces - -Offset 0x023BA (9146): - Valores distintos (4): 0x00, 0x01, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x01 -> 54 veces - 0x04 -> 46 veces - 0x03 -> 39 veces - -Offset 0x023BB (9147): - Valores distintos (3): 0x00, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 100 veces - 0x00 -> 95 veces - 0xFF -> 39 veces - -Offset 0x023BC (9148): - Valores distintos (3): 0x00, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0xFE -> 46 veces - 0xFF -> 39 veces - -Offset 0x023BD (9149): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 195 veces - 0xFF -> 39 veces - -Offset 0x023BE (9150): - Valores distintos (4): 0x00, 0x01, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x01 -> 54 veces - 0x04 -> 46 veces - 0xFF -> 39 veces - -Offset 0x023DE (9182): - Valores distintos (19): 0x0D, 0x0E, 0x10, 0x11, 0x12, 0x14, 0x15, 0x16, 0x17, 0x18, 0x1A, 0x1B, 0x1C, 0x1E, 0x22, 0x25, 0x2A, 0x2B, 0x2C - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 74 veces - 0x15 -> 36 veces - 0x16 -> 33 veces - 0x2C -> 23 veces - 0x18 -> 19 veces - -Offset 0x023DF (9183): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 163 veces - 0x00 -> 71 veces - -Offset 0x023E0 (9184): - Valores distintos (39): 0x06, 0x09, 0x11, 0x1B, 0x1C, 0x28, 0x2B, 0x30, 0x40, 0x45, 0x4B, 0x54, 0x60, 0x64, 0x68, 0x7A, 0x80, 0x8B, 0x8F, 0x9F, 0xA8, 0xB8, 0xBB, 0xBE, 0xC2, 0xC4, 0xCA, 0xCE, 0xD0, 0xD9, 0xDD, 0xE1, 0xE2, 0xE3, 0xE8, 0xE9, 0xEE, 0xF5, 0xF7 - Clasificación: bitfield_like - Más frecuentes: - 0xB8 -> 74 veces - 0x45 -> 30 veces - 0xE1 -> 23 veces - 0xE9 -> 18 veces - 0x09 -> 14 veces - -Offset 0x023E1 (9185): - Valores distintos (36): 0x0B, 0x0C, 0x0D, 0x0F, 0x10, 0x11, 0x19, 0x20, 0x27, 0x2A, 0x31, 0x33, 0x36, 0x3C, 0x3D, 0x3E, 0x42, 0x43, 0x45, 0x47, 0x48, 0x49, 0x52, 0x55, 0x5D, 0x5F, 0x62, 0x6B, 0x85, 0x8D, 0x92, 0xAB, 0xBF, 0xC1, 0xDB, 0xDD - Clasificación: bitfield_like - Más frecuentes: - 0x0B -> 71 veces - 0x49 -> 30 veces - 0xC1 -> 24 veces - 0x43 -> 18 veces - 0x62 -> 18 veces - -Offset 0x023E2 (9186): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 199 veces - 0x04 -> 24 veces - 0x01 -> 6 veces - 0x03 -> 3 veces - 0x02 -> 2 veces - -Offset 0x023E6 (9190): - Valores distintos (4): 0x29, 0x2A, 0x33, 0x52 - Clasificación: small_state - Más frecuentes: - 0x2A -> 110 veces - 0x29 -> 80 veces - 0x52 -> 30 veces - 0x33 -> 14 veces - -Offset 0x023E7 (9191): - Valores distintos (4): 0x00, 0x36, 0x3A, 0x3F - Clasificación: small_state - Más frecuentes: - 0x36 -> 103 veces - 0x00 -> 88 veces - 0x3F -> 29 veces - 0x3A -> 14 veces - -Offset 0x023E8 (9192): - Valores distintos (8): 0x00, 0x21, 0x23, 0x26, 0x27, 0x2A, 0x2C, 0x2D - Clasificación: small_state - Más frecuentes: - 0x26 -> 88 veces - 0x00 -> 79 veces - 0x2D -> 24 veces - 0x21 -> 16 veces - 0x2C -> 11 veces - -Offset 0x023E9 (9193): - Valores distintos (6): 0x00, 0x0A, 0x10, 0x15, 0x17, 0x1B - Clasificación: small_state - Más frecuentes: - 0x0A -> 121 veces - 0x15 -> 57 veces - 0x1B -> 24 veces - 0x10 -> 19 veces - 0x00 -> 8 veces - -Offset 0x023EA (9194): - Valores distintos (4): 0x00, 0x01, 0x0C, 0x14 - Clasificación: small_state - Más frecuentes: - 0x01 -> 121 veces - 0x00 -> 99 veces - 0x0C -> 12 veces - 0x14 -> 2 veces - -Offset 0x023EC (9196): - Valores distintos (33): 0x12, 0x24, 0x28, 0x2B, 0x30, 0x34, 0x38, 0x3B, 0x3F, 0x46, 0x47, 0x4C, 0x4E, 0x5F, 0x63, 0x64, 0x6C, 0x6D, 0x73, 0x77, 0x7F, 0x8B, 0x97, 0xAF, 0xB1, 0xB2, 0xBC, 0xC3, 0xC8, 0xD4, 0xDC, 0xE1, 0xF0 - Clasificación: bitfield_like - Más frecuentes: - 0x63 -> 72 veces - 0xB2 -> 33 veces - 0xBC -> 33 veces - 0x3F -> 22 veces - 0xC8 -> 18 veces - -Offset 0x023ED (9197): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 199 veces - 0x01 -> 35 veces - -Offset 0x023EE (9198): - Valores distintos (15): 0x03, 0x05, 0x07, 0x09, 0x0C, 0x0D, 0x10, 0x13, 0x14, 0x17, 0x18, 0x1C, 0x1E, 0x1F, 0x24 - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 89 veces - 0x0D -> 38 veces - 0x10 -> 34 veces - 0x24 -> 27 veces - 0x14 -> 19 veces - -Offset 0x023F1 (9201): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 233 veces - 0x01 -> 1 veces - -Offset 0x023F3 (9203): - Valores distintos (6): 0x00, 0x01, 0x04, 0x0A, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 71 veces - 0x04 -> 63 veces - 0x01 -> 62 veces - 0x10 -> 35 veces - 0x0A -> 2 veces - -Offset 0x023F4 (9204): - Valores distintos (19): 0x12, 0x24, 0x38, 0x3B, 0x3F, 0x63, 0x6C, 0x7F, 0x8B, 0x97, 0xA8, 0xB2, 0xBC, 0xC3, 0xC8, 0xD4, 0xDC, 0xE1, 0xF0 - Clasificación: bitfield_like - Más frecuentes: - 0x63 -> 74 veces - 0xB2 -> 36 veces - 0xBC -> 33 veces - 0x3F -> 23 veces - 0xC8 -> 19 veces - -Offset 0x023F5 (9205): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 199 veces - 0x01 -> 35 veces - -Offset 0x023F6 (9206): - Valores distintos (13): 0x07, 0x09, 0x0C, 0x0D, 0x10, 0x13, 0x14, 0x17, 0x18, 0x1C, 0x1E, 0x1F, 0x24 - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 90 veces - 0x0D -> 38 veces - 0x10 -> 33 veces - 0x24 -> 27 veces - 0x14 -> 19 veces - -Offset 0x023F8 (9208): - Valores distintos (21): 0x3C, 0x49, 0x4D, 0x4F, 0x54, 0x5A, 0x62, 0x6D, 0x72, 0x78, 0x7A, 0x7F, 0x81, 0x84, 0x85, 0xCA, 0xCF, 0xD9, 0xE0, 0xFA, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0x54 -> 74 veces - 0x7F -> 34 veces - 0x4F -> 23 veces - 0x84 -> 21 veces - 0x85 -> 19 veces - -Offset 0x023F9 (9209): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 205 veces - 0x01 -> 29 veces - -Offset 0x023FA (9210): - Valores distintos (25): 0x00, 0x0A, 0x15, 0x17, 0x41, 0x42, 0x48, 0x54, 0x56, 0x5B, 0x61, 0x66, 0x6F, 0x7A, 0x82, 0x8D, 0x8F, 0xA8, 0xAB, 0xAE, 0xC8, 0xCA, 0xD3, 0xD9, 0xE8 - Clasificación: bitfield_like - Más frecuentes: - 0x41 -> 71 veces - 0x17 -> 23 veces - 0x82 -> 21 veces - 0xA8 -> 21 veces - 0xAE -> 19 veces - -Offset 0x023FB (9211): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 205 veces - 0x01 -> 29 veces - -Offset 0x023FC (9212): - Valores distintos (10): 0x00, 0x04, 0x05, 0x06, 0x08, 0x09, 0x0E, 0x14, 0x17, 0x1A - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 80 veces - 0x05 -> 44 veces - 0x06 -> 42 veces - 0x04 -> 23 veces - 0x1A -> 23 veces - -Offset 0x023FE (9214): - Valores distintos (13): 0x15, 0x18, 0x1D, 0x1F, 0x29, 0x2C, 0x2E, 0x35, 0x38, 0x3D, 0x43, 0x45, 0x46 - Clasificación: bitfield_like - Más frecuentes: - 0x15 -> 136 veces - 0x18 -> 33 veces - 0x46 -> 23 veces - 0x1F -> 19 veces - 0x38 -> 6 veces - -Offset 0x02403 (9219): - Valores distintos (2): 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x04 -> 209 veces - 0x06 -> 25 veces - -Offset 0x02405 (9221): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 222 veces - 0x07 -> 12 veces - -Offset 0x02409 (9225): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 210 veces - 0x07 -> 24 veces - -Offset 0x0240C (9228): - Valores distintos (2): 0x37, 0x3C - Clasificación: small_state - Más frecuentes: - 0x37 -> 170 veces - 0x3C -> 64 veces - -Offset 0x0240F (9231): - Valores distintos (4): 0x00, 0x02, 0x04, 0x0E - Clasificación: small_state - Más frecuentes: - 0x04 -> 73 veces - 0x02 -> 64 veces - 0x00 -> 62 veces - 0x0E -> 35 veces - -Offset 0x02414 (9236): - Valores distintos (19): 0x12, 0x24, 0x38, 0x3B, 0x3F, 0x63, 0x6C, 0x7F, 0x8B, 0x97, 0xA8, 0xB2, 0xBC, 0xC3, 0xC8, 0xD4, 0xDC, 0xE1, 0xF0 - Clasificación: bitfield_like - Más frecuentes: - 0x63 -> 74 veces - 0xB2 -> 36 veces - 0xBC -> 33 veces - 0x3F -> 23 veces - 0xC8 -> 19 veces - -Offset 0x02415 (9237): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 199 veces - 0x01 -> 35 veces - -Offset 0x02416 (9238): - Valores distintos (13): 0x07, 0x09, 0x0C, 0x0D, 0x10, 0x13, 0x14, 0x17, 0x18, 0x1C, 0x1E, 0x1F, 0x24 - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 90 veces - 0x0D -> 38 veces - 0x10 -> 33 veces - 0x24 -> 27 veces - 0x14 -> 19 veces - -Offset 0x02418 (9240): - Valores distintos (19): 0x3A, 0x40, 0x4B, 0x50, 0x56, 0x5D, 0x62, 0x67, 0x69, 0x6D, 0x72, 0x77, 0x7C, 0x83, 0x9D, 0xA6, 0xB3, 0xB7, 0xB9 - Clasificación: bitfield_like - Más frecuentes: - 0x3A -> 74 veces - 0x62 -> 36 veces - 0x67 -> 33 veces - 0xB9 -> 23 veces - 0x6D -> 19 veces - -Offset 0x0241A (9242): - Valores distintos (18): 0x2C, 0x32, 0x3D, 0x42, 0x48, 0x53, 0x5B, 0x5D, 0x60, 0x63, 0x67, 0x69, 0x6D, 0x73, 0x82, 0x87, 0x91, 0x93 - Clasificación: bitfield_like - Más frecuentes: - 0x2C -> 74 veces - 0x5B -> 36 veces - 0x5D -> 33 veces - 0x93 -> 23 veces - 0x63 -> 19 veces - -Offset 0x0241C (9244): - Valores distintos (10): 0x11, 0x12, 0x13, 0x14, 0x16, 0x18, 0x21, 0x2F, 0x32, 0x35 - Clasificación: bitfield_like - Más frecuentes: - 0x11 -> 136 veces - 0x12 -> 33 veces - 0x35 -> 23 veces - 0x14 -> 21 veces - 0x18 -> 9 veces - -Offset 0x0241E (9246): - Valores distintos (13): 0x15, 0x18, 0x1D, 0x1F, 0x29, 0x2C, 0x2E, 0x35, 0x38, 0x3D, 0x43, 0x45, 0x46 - Clasificación: bitfield_like - Más frecuentes: - 0x15 -> 136 veces - 0x18 -> 33 veces - 0x46 -> 23 veces - 0x1F -> 19 veces - 0x38 -> 6 veces - -Offset 0x0244A (9290): - Valores distintos (2): 0x00, 0x5C - Clasificación: small_state - Más frecuentes: - 0x5C -> 160 veces - 0x00 -> 74 veces - -Offset 0x0244B (9291): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 134 veces - 0x00 -> 100 veces - -Offset 0x0244C (9292): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0x69 -> 43 veces - -Offset 0x0244D (9293): - Valores distintos (2): 0x00, 0x5D - Clasificación: small_state - Más frecuentes: - 0x00 -> 196 veces - 0x5D -> 38 veces - -Offset 0x02452 (9298): - Valores distintos (3): 0x00, 0x0F, 0x26 - Clasificación: small_state - Más frecuentes: - 0x0F -> 106 veces - 0x00 -> 105 veces - 0x26 -> 23 veces - -Offset 0x02453 (9299): - Valores distintos (2): 0x00, 0x1A - Clasificación: small_state - Más frecuentes: - 0x1A -> 129 veces - 0x00 -> 105 veces - -Offset 0x02454 (9300): - Valores distintos (2): 0x00, 0x99 - Clasificación: small_state - Más frecuentes: - 0x99 -> 129 veces - 0x00 -> 105 veces - -Offset 0x02455 (9301): - Valores distintos (2): 0x00, 0xC4 - Clasificación: small_state - Más frecuentes: - 0x00 -> 218 veces - 0xC4 -> 16 veces - -Offset 0x02456 (9302): - Valores distintos (2): 0x00, 0xA3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 218 veces - 0xA3 -> 16 veces - -Offset 0x02457 (9303): - Valores distintos (2): 0x00, 0xAC - Clasificación: small_state - Más frecuentes: - 0x00 -> 195 veces - 0xAC -> 39 veces - -Offset 0x02458 (9304): - Valores distintos (2): 0x00, 0xCB - Clasificación: small_state - Más frecuentes: - 0x00 -> 197 veces - 0xCB -> 37 veces - -Offset 0x02459 (9305): - Valores distintos (2): 0x00, 0x9A - Clasificación: small_state - Más frecuentes: - 0x00 -> 199 veces - 0x9A -> 35 veces - -Offset 0x0245A (9306): - Valores distintos (2): 0x00, 0x9D - Clasificación: small_state - Más frecuentes: - 0x00 -> 199 veces - 0x9D -> 35 veces - -Offset 0x0245B (9307): - Valores distintos (2): 0x00, 0xAB - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0xAB -> 25 veces - -Offset 0x0245C (9308): - Valores distintos (5): 0x00, 0x0D, 0x15, 0x1E, 0x22 - Clasificación: small_state - Más frecuentes: - 0x00 -> 71 veces - 0x0D -> 64 veces - 0x15 -> 62 veces - 0x22 -> 35 veces - 0x1E -> 2 veces - -Offset 0x0245D (9309): - Valores distintos (4): 0x00, 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 133 veces - 0x04 -> 63 veces - 0xFF -> 35 veces - 0x02 -> 3 veces - -Offset 0x0245E (9310): - Valores distintos (3): 0x00, 0x01, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 169 veces - 0x01 -> 62 veces - 0xFE -> 3 veces - -Offset 0x0245F (9311): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 97 veces - 0x00 -> 71 veces - 0x01 -> 63 veces - 0x02 -> 3 veces - -Offset 0x02460 (9312): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 97 veces - 0x00 -> 71 veces - 0x03 -> 63 veces - 0x01 -> 3 veces - -Offset 0x02461 (9313): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 134 veces - 0xFD -> 63 veces - 0x02 -> 35 veces - 0xFF -> 2 veces - -Offset 0x02462 (9314): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 106 veces - 0xFD -> 64 veces - 0x02 -> 62 veces - 0xFF -> 2 veces - -Offset 0x02482 (9346): - Valores distintos (6): 0x01, 0x03, 0x06, 0x07, 0x08, 0x09 - Clasificación: small_state - Más frecuentes: - 0x09 -> 218 veces - 0x01 -> 5 veces - 0x06 -> 5 veces - 0x07 -> 3 veces - 0x03 -> 2 veces - -Offset 0x02483 (9347): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 219 veces - 0x01 -> 15 veces - -Offset 0x02484 (9348): - Valores distintos (9): 0x00, 0x2A, 0x50, 0x54, 0x81, 0xA4, 0xB4, 0xDD, 0xF3 - Clasificación: bitfield_like - Más frecuentes: - 0x81 -> 214 veces - 0x00 -> 5 veces - 0xDD -> 4 veces - 0xB4 -> 3 veces - 0x2A -> 2 veces - -Offset 0x02485 (9349): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 214 veces - 0x00 -> 12 veces - 0x02 -> 5 veces - 0x01 -> 3 veces - -Offset 0x0248A (9354): - Valores distintos (2): 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 227 veces - 0x01 -> 7 veces - -Offset 0x0248B (9355): - Valores distintos (3): 0x00, 0x32, 0x33 - Clasificación: small_state - Más frecuentes: - 0x33 -> 222 veces - 0x00 -> 7 veces - 0x32 -> 5 veces - -Offset 0x0248C (9356): - Valores distintos (3): 0x00, 0x21, 0x23 - Clasificación: small_state - Más frecuentes: - 0x23 -> 222 veces - 0x00 -> 7 veces - 0x21 -> 5 veces - -Offset 0x0248D (9357): - Valores distintos (2): 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 224 veces - 0x01 -> 10 veces - -Offset 0x02490 (9360): - Valores distintos (8): 0x0C, 0x16, 0x17, 0x1B, 0x1E, 0x2C, 0x31, 0x36 - Clasificación: small_state - Más frecuentes: - 0x36 -> 196 veces - 0x31 -> 23 veces - 0x16 -> 5 veces - 0x0C -> 3 veces - 0x1B -> 2 veces - -Offset 0x02492 (9362): - Valores distintos (7): 0x0D, 0x0F, 0x13, 0x14, 0x1C, 0x20, 0x23 - Clasificación: small_state - Más frecuentes: - 0x23 -> 218 veces - 0x0D -> 5 veces - 0x13 -> 3 veces - 0x1C -> 3 veces - 0x0F -> 2 veces - -Offset 0x02496 (9366): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 212 veces - 0x01 -> 22 veces - -Offset 0x02498 (9368): - Valores distintos (6): 0x16, 0x1B, 0x29, 0x2C, 0x31, 0x36 - Clasificación: small_state - Más frecuentes: - 0x36 -> 196 veces - 0x31 -> 23 veces - 0x16 -> 5 veces - 0x29 -> 5 veces - 0x2C -> 3 veces - -Offset 0x0249A (9370): - Valores distintos (6): 0x0D, 0x0F, 0x18, 0x1C, 0x20, 0x23 - Clasificación: small_state - Más frecuentes: - 0x23 -> 218 veces - 0x0D -> 5 veces - 0x18 -> 5 veces - 0x1C -> 3 veces - 0x0F -> 2 veces - -Offset 0x0249C (9372): - Valores distintos (6): 0x11, 0x14, 0x1B, 0x1F, 0x21, 0x24 - Clasificación: small_state - Más frecuentes: - 0x24 -> 218 veces - 0x11 -> 5 veces - 0x1B -> 5 veces - 0x1F -> 3 veces - 0x14 -> 2 veces - -Offset 0x0249E (9374): - Valores distintos (7): 0x0C, 0x0D, 0x14, 0x16, 0x1C, 0x1F, 0x22 - Clasificación: small_state - Más frecuentes: - 0x22 -> 218 veces - 0x0C -> 5 veces - 0x14 -> 3 veces - 0x1C -> 3 veces - 0x0D -> 2 veces - -Offset 0x024A0 (9376): - Valores distintos (5): 0x06, 0x07, 0x08, 0x09, 0x0A - Clasificación: small_state - Más frecuentes: - 0x08 -> 219 veces - 0x06 -> 5 veces - 0x07 -> 5 veces - 0x0A -> 3 veces - 0x09 -> 2 veces - -Offset 0x024A2 (9378): - Valores distintos (5): 0x0C, 0x0F, 0x18, 0x1D, 0x21 - Clasificación: small_state - Más frecuentes: - 0x21 -> 218 veces - 0x18 -> 8 veces - 0x0C -> 5 veces - 0x0F -> 2 veces - 0x1D -> 1 veces - -Offset 0x024B8 (9400): - Valores distintos (6): 0x16, 0x1B, 0x29, 0x2C, 0x31, 0x36 - Clasificación: small_state - Más frecuentes: - 0x36 -> 218 veces - 0x16 -> 5 veces - 0x29 -> 5 veces - 0x2C -> 3 veces - 0x1B -> 2 veces - -Offset 0x024BA (9402): - Valores distintos (6): 0x0D, 0x0F, 0x18, 0x1C, 0x20, 0x23 - Clasificación: small_state - Más frecuentes: - 0x23 -> 218 veces - 0x0D -> 5 veces - 0x18 -> 5 veces - 0x1C -> 3 veces - 0x0F -> 2 veces - -Offset 0x024BC (9404): - Valores distintos (6): 0x0D, 0x10, 0x15, 0x19, 0x1B, 0x1E - Clasificación: small_state - Más frecuentes: - 0x1E -> 218 veces - 0x0D -> 5 veces - 0x15 -> 5 veces - 0x19 -> 3 veces - 0x10 -> 2 veces - -Offset 0x024BE (9406): - Valores distintos (6): 0x0A, 0x0B, 0x10, 0x12, 0x15, 0x18 - Clasificación: small_state - Más frecuentes: - 0x18 -> 218 veces - 0x0A -> 5 veces - 0x10 -> 5 veces - 0x12 -> 3 veces - 0x0B -> 2 veces - -Offset 0x024C0 (9408): - Valores distintos (4): 0x0A, 0x0B, 0x0E, 0x0F - Clasificación: small_state - Más frecuentes: - 0x0F -> 219 veces - 0x0E -> 8 veces - 0x0A -> 5 veces - 0x0B -> 2 veces - -Offset 0x024C2 (9410): - Valores distintos (5): 0x0C, 0x0F, 0x18, 0x1D, 0x21 - Clasificación: small_state - Más frecuentes: - 0x21 -> 218 veces - 0x18 -> 8 veces - 0x0C -> 5 veces - 0x0F -> 2 veces - 0x1D -> 1 veces - -Offset 0x024ED (9453): - Valores distintos (2): 0x00, 0x5E - Clasificación: small_state - Más frecuentes: - 0x5E -> 227 veces - 0x00 -> 7 veces - -Offset 0x024EE (9454): - Valores distintos (2): 0x00, 0x67 - Clasificación: small_state - Más frecuentes: - 0x67 -> 222 veces - 0x00 -> 12 veces - -Offset 0x02526 (9510): - Valores distintos (26): 0x05, 0x07, 0x08, 0x09, 0x14, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x21, 0x22, 0x23, 0x25, 0x26, 0x27, 0x29, 0x2D, 0x2E, 0x2F, 0x30 - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 84 veces - 0x17 -> 35 veces - 0x2F -> 14 veces - 0x19 -> 12 veces - 0x14 -> 9 veces - -Offset 0x02527 (9511): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 143 veces - 0x00 -> 91 veces - -Offset 0x02528 (9512): - Valores distintos (55): 0x08, 0x0C, 0x0E, 0x1B, 0x1C, 0x21, 0x22, 0x28, 0x2E, 0x33, 0x37, 0x38, 0x49, 0x4A, 0x4D, 0x50, 0x5A, 0x64, 0x68, 0x6A, 0x6D, 0x6E, 0x73, 0x7A, 0x7B, 0x7D, 0x7F, 0x80, 0x81, 0x84, 0x8E, 0x93, 0x9B, 0x9C, 0xA5, 0xAA, 0xAD, 0xB0, 0xB1, 0xB8, 0xC4, 0xC8, 0xD2, 0xD3, 0xDE, 0xDF, 0xE0, 0xE9, 0xED, 0xEF, 0xF0, 0xF1, 0xF5, 0xF8, 0xFC - Clasificación: bitfield_like - Más frecuentes: - 0x7B -> 92 veces - 0xD3 -> 35 veces - 0xE0 -> 12 veces - 0x0E -> 6 veces - 0x5A -> 5 veces - -Offset 0x02529 (9513): - Valores distintos (46): 0x00, 0x01, 0x02, 0x08, 0x0E, 0x0F, 0x15, 0x18, 0x20, 0x2D, 0x2E, 0x33, 0x34, 0x37, 0x3D, 0x40, 0x41, 0x42, 0x49, 0x4C, 0x4E, 0x52, 0x58, 0x5E, 0x67, 0x6A, 0x70, 0x74, 0x78, 0x7B, 0x7E, 0x88, 0x8E, 0x93, 0x9F, 0xB6, 0xBD, 0xBF, 0xC3, 0xC7, 0xCA, 0xCB, 0xCF, 0xD2, 0xE3, 0xF9 - Clasificación: bitfield_like - Más frecuentes: - 0x02 -> 84 veces - 0x41 -> 35 veces - 0x01 -> 13 veces - 0x5E -> 12 veces - 0x2E -> 8 veces - -Offset 0x0252A (9514): - Valores distintos (6): 0x00, 0x01, 0x02, 0x04, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0x05 -> 18 veces - 0x01 -> 14 veces - 0x06 -> 8 veces - 0x02 -> 6 veces - -Offset 0x0252C (9516): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0x80 -> 1 veces - -Offset 0x0252E (9518): - Valores distintos (8): 0x02, 0x03, 0x04, 0x07, 0x09, 0x0E, 0x12, 0x43 - Clasificación: small_state - Más frecuentes: - 0x04 -> 84 veces - 0x09 -> 37 veces - 0x43 -> 33 veces - 0x12 -> 28 veces - 0x0E -> 23 veces - -Offset 0x0252F (9519): - Valores distintos (7): 0x00, 0x32, 0x33, 0x38, 0x3B, 0x3C, 0x40 - Clasificación: small_state - Más frecuentes: - 0x33 -> 92 veces - 0x3B -> 54 veces - 0x00 -> 29 veces - 0x40 -> 22 veces - 0x38 -> 17 veces - -Offset 0x02530 (9520): - Valores distintos (7): 0x00, 0x21, 0x23, 0x26, 0x27, 0x2A, 0x2D - Clasificación: small_state - Más frecuentes: - 0x23 -> 94 veces - 0x2A -> 60 veces - 0x00 -> 36 veces - 0x2D -> 22 veces - 0x21 -> 12 veces - -Offset 0x02531 (9521): - Valores distintos (6): 0x00, 0x02, 0x0E, 0x10, 0x14, 0x1A - Clasificación: small_state - Más frecuentes: - 0x02 -> 104 veces - 0x1A -> 44 veces - 0x14 -> 40 veces - 0x00 -> 29 veces - 0x0E -> 9 veces - -Offset 0x02532 (9522): - Valores distintos (4): 0x00, 0x04, 0x0B, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 178 veces - 0x04 -> 47 veces - 0x0C -> 8 veces - 0x0B -> 1 veces - -Offset 0x02533 (9523): - Valores distintos (3): 0x00, 0x02, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 173 veces - 0x02 -> 48 veces - 0x0B -> 13 veces - -Offset 0x02534 (9524): - Valores distintos (31): 0x1B, 0x2A, 0x2B, 0x2C, 0x33, 0x35, 0x38, 0x3A, 0x3E, 0x53, 0x58, 0x64, 0x6A, 0x6B, 0x6C, 0x6F, 0x73, 0x76, 0x7C, 0x7E, 0x83, 0x84, 0x8C, 0x8D, 0x92, 0x93, 0x95, 0x97, 0x9A, 0x9C, 0xA1 - Clasificación: bitfield_like - Más frecuentes: - 0x3E -> 62 veces - 0xA1 -> 40 veces - 0x84 -> 34 veces - 0x38 -> 24 veces - 0x93 -> 12 veces - -Offset 0x02536 (9526): - Valores distintos (9): 0x0C, 0x0D, 0x10, 0x12, 0x23, 0x24, 0x25, 0x26, 0x27 - Clasificación: bitfield_like - Más frecuentes: - 0x12 -> 84 veces - 0x27 -> 81 veces - 0x26 -> 34 veces - 0x23 -> 9 veces - 0x10 -> 8 veces - -Offset 0x02538 (9528): - Valores distintos (2): 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 209 veces - 0x01 -> 25 veces - -Offset 0x0253A (9530): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x01 -> 24 veces - 0x02 -> 1 veces - -Offset 0x0253B (9531): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 108 veces - 0x00 -> 67 veces - 0x0F -> 59 veces - -Offset 0x0253C (9532): - Valores distintos (14): 0x2A, 0x33, 0x38, 0x3A, 0x3E, 0x6F, 0x7B, 0x7C, 0x84, 0x8B, 0x8D, 0x93, 0x9A, 0xA1 - Clasificación: bitfield_like - Más frecuentes: - 0x3E -> 62 veces - 0xA1 -> 61 veces - 0x84 -> 35 veces - 0x38 -> 22 veces - 0x93 -> 12 veces - -Offset 0x0253E (9534): - Valores distintos (8): 0x0C, 0x0D, 0x10, 0x12, 0x23, 0x24, 0x26, 0x27 - Clasificación: small_state - Más frecuentes: - 0x12 -> 84 veces - 0x27 -> 82 veces - 0x26 -> 35 veces - 0x23 -> 9 veces - 0x10 -> 8 veces - -Offset 0x02540 (9536): - Valores distintos (28): 0x0B, 0x0F, 0x11, 0x16, 0x1D, 0x24, 0x29, 0x32, 0x62, 0x74, 0x78, 0x95, 0x97, 0x9D, 0xA3, 0xC0, 0xC4, 0xC9, 0xCE, 0xD0, 0xD5, 0xDF, 0xE1, 0xE4, 0xEA, 0xEE, 0xEF, 0xF9 - Clasificación: bitfield_like - Más frecuentes: - 0x32 -> 84 veces - 0x78 -> 33 veces - 0x11 -> 14 veces - 0x9D -> 12 veces - 0x62 -> 9 veces - -Offset 0x02541 (9537): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 207 veces - 0x01 -> 27 veces - -Offset 0x02542 (9538): - Valores distintos (30): 0x0C, 0x11, 0x14, 0x1A, 0x1B, 0x1C, 0x1E, 0x20, 0x21, 0x23, 0x39, 0x56, 0x72, 0x74, 0x94, 0x9F, 0xA3, 0xA4, 0xAD, 0xB0, 0xB4, 0xB9, 0xBF, 0xC6, 0xDE, 0xE3, 0xEA, 0xEF, 0xF3, 0xFB - Clasificación: bitfield_like - Más frecuentes: - 0x23 -> 84 veces - 0x39 -> 29 veces - 0xA3 -> 12 veces - 0x56 -> 9 veces - 0xE3 -> 9 veces - -Offset 0x02543 (9539): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 207 veces - 0x01 -> 27 veces - -Offset 0x02544 (9540): - Valores distintos (26): 0x0E, 0x0F, 0x10, 0x11, 0x1B, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x25, 0x26, 0x28, 0x2B, 0x2D, 0x31, 0x33, 0x35, 0x39, 0x3F, 0x41, 0x45, 0x51, 0x52, 0x55, 0x57 - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 91 veces - 0x25 -> 32 veces - 0x55 -> 14 veces - 0x21 -> 12 veces - 0x20 -> 12 veces - -Offset 0x02546 (9542): - Valores distintos (25): 0x16, 0x19, 0x1D, 0x1E, 0x35, 0x36, 0x37, 0x55, 0x59, 0x5D, 0x61, 0x64, 0x6B, 0x71, 0x75, 0x79, 0x7F, 0x85, 0x8A, 0x8D, 0x8E, 0x9E, 0xA1, 0xA6, 0xA8 - Clasificación: bitfield_like - Más frecuentes: - 0x1E -> 84 veces - 0x35 -> 53 veces - 0x36 -> 16 veces - 0x75 -> 9 veces - 0x1D -> 8 veces - -Offset 0x0254B (9547): - Valores distintos (4): 0x02, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 174 veces - 0x05 -> 37 veces - 0x07 -> 14 veces - 0x06 -> 9 veces - -Offset 0x0254C (9548): - Valores distintos (3): 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x02 -> 172 veces - 0x06 -> 32 veces - 0x04 -> 30 veces - -Offset 0x0254D (9549): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 226 veces - 0x07 -> 8 veces - -Offset 0x02551 (9553): - Valores distintos (2): 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x02 -> 212 veces - 0x04 -> 22 veces - -Offset 0x02552 (9554): - Valores distintos (2): 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x02 -> 175 veces - 0x03 -> 59 veces - -Offset 0x02553 (9555): - Valores distintos (2): 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x02 -> 175 veces - 0x03 -> 59 veces - -Offset 0x02556 (9558): - Valores distintos (2): 0x05, 0x0D - Clasificación: small_state - Más frecuentes: - 0x05 -> 201 veces - 0x0D -> 33 veces - -Offset 0x0255C (9564): - Valores distintos (11): 0x2A, 0x33, 0x3A, 0x3E, 0x6F, 0x7C, 0x84, 0x8D, 0x93, 0x9A, 0xA1 - Clasificación: bitfield_like - Más frecuentes: - 0x3E -> 84 veces - 0xA1 -> 61 veces - 0x84 -> 35 veces - 0x93 -> 12 veces - 0x6F -> 9 veces - -Offset 0x0255E (9566): - Valores distintos (8): 0x0C, 0x0D, 0x10, 0x12, 0x23, 0x24, 0x26, 0x27 - Clasificación: small_state - Más frecuentes: - 0x12 -> 84 veces - 0x27 -> 82 veces - 0x26 -> 35 veces - 0x23 -> 9 veces - 0x10 -> 8 veces - -Offset 0x02560 (9568): - Valores distintos (26): 0x17, 0x1E, 0x21, 0x23, 0x42, 0x4E, 0x52, 0x54, 0x5A, 0x60, 0x65, 0x69, 0x6E, 0x73, 0x75, 0x81, 0x84, 0x89, 0x93, 0x95, 0x9A, 0xA4, 0xB6, 0xBA, 0xBC, 0xC1 - Clasificación: bitfield_like - Más frecuentes: - 0x23 -> 84 veces - 0x52 -> 35 veces - 0xBC -> 14 veces - 0x5A -> 12 veces - 0x42 -> 9 veces - -Offset 0x02562 (9570): - Valores distintos (26): 0x0F, 0x14, 0x17, 0x19, 0x30, 0x37, 0x39, 0x3E, 0x42, 0x43, 0x47, 0x4A, 0x4E, 0x53, 0x59, 0x60, 0x63, 0x68, 0x6F, 0x74, 0x78, 0x80, 0x91, 0x96, 0x9B, 0x9E - Clasificación: bitfield_like - Más frecuentes: - 0x19 -> 84 veces - 0x39 -> 35 veces - 0x9B -> 14 veces - 0x42 -> 12 veces - 0x30 -> 9 veces - -Offset 0x02564 (9572): - Valores distintos (24): 0x13, 0x16, 0x17, 0x27, 0x29, 0x2C, 0x2E, 0x30, 0x31, 0x35, 0x36, 0x38, 0x3B, 0x3F, 0x43, 0x45, 0x49, 0x4C, 0x4E, 0x52, 0x5E, 0x5F, 0x62, 0x64 - Clasificación: bitfield_like - Más frecuentes: - 0x17 -> 92 veces - 0x29 -> 39 veces - 0x62 -> 14 veces - 0x2E -> 12 veces - 0x27 -> 9 veces - -Offset 0x02566 (9574): - Valores distintos (22): 0x16, 0x19, 0x1D, 0x1E, 0x35, 0x36, 0x37, 0x3B, 0x3F, 0x43, 0x46, 0x4D, 0x53, 0x57, 0x5B, 0x61, 0x67, 0x6F, 0x80, 0x83, 0x85, 0x89 - Clasificación: bitfield_like - Más frecuentes: - 0x1E -> 84 veces - 0x35 -> 53 veces - 0x36 -> 16 veces - 0x85 -> 14 veces - 0x57 -> 9 veces - -Offset 0x02586 (9606): - Valores distintos (2): 0x00, 0x58 - Clasificación: small_state - Más frecuentes: - 0x58 -> 130 veces - 0x00 -> 104 veces - -Offset 0x02587 (9607): - Valores distintos (2): 0x00, 0x57 - Clasificación: small_state - Más frecuentes: - 0x57 -> 130 veces - 0x00 -> 104 veces - -Offset 0x02588 (9608): - Valores distintos (2): 0x00, 0x54 - Clasificación: small_state - Más frecuentes: - 0x54 -> 130 veces - 0x00 -> 104 veces - -Offset 0x02591 (9617): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x61 -> 214 veces - 0x00 -> 20 veces - -Offset 0x02592 (9618): - Valores distintos (2): 0x00, 0x62 - Clasificación: small_state - Más frecuentes: - 0x62 -> 130 veces - 0x00 -> 104 veces - -Offset 0x02593 (9619): - Valores distintos (2): 0x00, 0x40 - Clasificación: small_state - Más frecuentes: - 0x40 -> 130 veces - 0x00 -> 104 veces - -Offset 0x02594 (9620): - Valores distintos (2): 0x00, 0x6A - Clasificación: small_state - Más frecuentes: - 0x00 -> 179 veces - 0x6A -> 55 veces - -Offset 0x02595 (9621): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x63 -> 33 veces - -Offset 0x0259A (9626): - Valores distintos (3): 0x00, 0x16, 0x45 - Clasificación: small_state - Más frecuentes: - 0x00 -> 171 veces - 0x16 -> 56 veces - 0x45 -> 7 veces - -Offset 0x0259B (9627): - Valores distintos (2): 0x00, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 182 veces - 0x2A -> 52 veces - -Offset 0x0259C (9628): - Valores distintos (2): 0x00, 0x9C - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x9C -> 25 veces - -Offset 0x0259D (9629): - Valores distintos (2): 0x00, 0x2B - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x2B -> 25 veces - -Offset 0x0259E (9630): - Valores distintos (2): 0x00, 0x13 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x13 -> 25 veces - -Offset 0x025A4 (9636): - Valores distintos (3): 0x00, 0x14, 0x1B - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0x14 -> 67 veces - 0x1B -> 59 veces - -Offset 0x025A5 (9637): - Valores distintos (3): 0x00, 0x02, 0xFA - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0x02 -> 67 veces - 0xFA -> 59 veces - -Offset 0x025A6 (9638): - Valores distintos (3): 0x00, 0xFA, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0xFE -> 67 veces - 0xFA -> 59 veces - -Offset 0x025A7 (9639): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 126 veces - 0x00 -> 108 veces - -Offset 0x025A8 (9640): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0x01 -> 67 veces - 0x02 -> 59 veces - -Offset 0x025A9 (9641): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 175 veces - 0x01 -> 59 veces - -Offset 0x025AA (9642): - Valores distintos (3): 0x00, 0x02, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0xFD -> 67 veces - 0x02 -> 59 veces - -Offset 0x025CA (9674): - Valores distintos (28): 0x0A, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12, 0x13, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x23, 0x24, 0x26, 0x27, 0x2A, 0x2C, 0x2D, 0x2E - Clasificación: bitfield_like - Más frecuentes: - 0x0A -> 46 veces - 0x16 -> 29 veces - 0x0F -> 26 veces - 0x13 -> 18 veces - 0x2D -> 14 veces - -Offset 0x025CB (9675): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 170 veces - 0x00 -> 64 veces - -Offset 0x025CC (9676): - Valores distintos (68): 0x01, 0x02, 0x03, 0x08, 0x09, 0x0F, 0x11, 0x14, 0x16, 0x18, 0x1A, 0x1B, 0x1C, 0x1F, 0x22, 0x37, 0x3C, 0x3E, 0x41, 0x42, 0x44, 0x45, 0x48, 0x4C, 0x51, 0x52, 0x53, 0x55, 0x59, 0x5B, 0x5F, 0x61, 0x63, 0x71, 0x7D, 0x81, 0x83, 0x84, 0x88, 0x8A, 0x8E, 0x92, 0x93, 0x97, 0x99, 0xA4, 0xA9, 0xB0, 0xB3, 0xB5, 0xB8, 0xBB, 0xBF, 0xC8, 0xC9, 0xCF, 0xD2, 0xD8, 0xDE, 0xE2, 0xE5, 0xE8, 0xE9, 0xEC, 0xF4, 0xF6, 0xF7, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xE8 -> 52 veces - 0x51 -> 19 veces - 0xBF -> 18 veces - 0xF4 -> 12 veces - 0x11 -> 10 veces - -Offset 0x025CD (9677): - Valores distintos (61): 0x03, 0x06, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x15, 0x17, 0x1A, 0x1B, 0x22, 0x28, 0x30, 0x33, 0x3B, 0x3D, 0x43, 0x4A, 0x4E, 0x4F, 0x53, 0x55, 0x59, 0x5C, 0x5F, 0x60, 0x64, 0x76, 0x89, 0x90, 0x94, 0x97, 0x9C, 0x9F, 0xA0, 0xA6, 0xAA, 0xAB, 0xAE, 0xB2, 0xB3, 0xB8, 0xBC, 0xBE, 0xC0, 0xC3, 0xC6, 0xCF, 0xD5, 0xD7, 0xDA, 0xE5, 0xED - Clasificación: bitfield_like - Más frecuentes: - 0x03 -> 49 veces - 0x12 -> 21 veces - 0x28 -> 18 veces - 0x43 -> 15 veces - 0x3D -> 10 veces - -Offset 0x025CE (9678): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x01 -> 20 veces - 0x04 -> 18 veces - 0x05 -> 8 veces - 0x02 -> 5 veces - -Offset 0x025D1 (9681): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 231 veces - 0x20 -> 3 veces - -Offset 0x025D2 (9682): - Valores distintos (7): 0x46, 0x49, 0x4A, 0x4B, 0x4C, 0x4E, 0x50 - Clasificación: small_state - Más frecuentes: - 0x46 -> 95 veces - 0x4A -> 44 veces - 0x4C -> 23 veces - 0x50 -> 22 veces - 0x4E -> 21 veces - -Offset 0x025D3 (9683): - Valores distintos (5): 0x00, 0x32, 0x36, 0x3C, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 90 veces - 0x36 -> 52 veces - 0x3C -> 52 veces - 0x3E -> 32 veces - 0x32 -> 8 veces - -Offset 0x025D4 (9684): - Valores distintos (5): 0x00, 0x26, 0x29, 0x2B, 0x2F - Clasificación: small_state - Más frecuentes: - 0x26 -> 120 veces - 0x2B -> 54 veces - 0x29 -> 33 veces - 0x2F -> 20 veces - 0x00 -> 7 veces - -Offset 0x025D5 (9685): - Valores distintos (7): 0x00, 0x06, 0x08, 0x10, 0x12, 0x16, 0x18 - Clasificación: small_state - Más frecuentes: - 0x08 -> 66 veces - 0x06 -> 46 veces - 0x18 -> 44 veces - 0x12 -> 38 veces - 0x10 -> 23 veces - -Offset 0x025D6 (9686): - Valores distintos (4): 0x00, 0x02, 0x04, 0x0B - Clasificación: small_state - Más frecuentes: - 0x02 -> 114 veces - 0x0B -> 60 veces - 0x00 -> 59 veces - 0x04 -> 1 veces - -Offset 0x025D7 (9687): - Valores distintos (8): 0x00, 0x01, 0x09, 0x0A, 0x0B, 0x0C, 0x14, 0x19 - Clasificación: small_state - Más frecuentes: - 0x00 -> 73 veces - 0x09 -> 40 veces - 0x0B -> 28 veces - 0x0A -> 27 veces - 0x0C -> 27 veces - -Offset 0x025D8 (9688): - Valores distintos (49): 0x01, 0x05, 0x14, 0x17, 0x19, 0x1E, 0x20, 0x2C, 0x2D, 0x2E, 0x34, 0x35, 0x36, 0x38, 0x3C, 0x3F, 0x41, 0x42, 0x47, 0x49, 0x4C, 0x4F, 0x50, 0x5A, 0x65, 0x6A, 0x6B, 0x6E, 0x70, 0x71, 0x75, 0x7C, 0x82, 0x89, 0x8E, 0x90, 0x96, 0x98, 0x9B, 0xA0, 0xA4, 0xAD, 0xAE, 0xB2, 0xB4, 0xB7, 0xBA, 0xBD, 0xBF - Clasificación: bitfield_like - Más frecuentes: - 0x34 -> 46 veces - 0x65 -> 27 veces - 0x49 -> 19 veces - 0x5A -> 18 veces - 0xAD -> 10 veces - -Offset 0x025DA (9690): - Valores distintos (39): 0x0A, 0x12, 0x14, 0x16, 0x1B, 0x22, 0x27, 0x28, 0x29, 0x2E, 0x30, 0x32, 0x35, 0x38, 0x3E, 0x49, 0x4F, 0x53, 0x56, 0x5A, 0x5B, 0x5C, 0x5D, 0x62, 0x65, 0x69, 0x6E, 0x70, 0x78, 0x7B, 0x7E, 0x88, 0x8C, 0x99, 0x9D, 0x9F, 0xA6, 0xAB, 0xB1 - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 47 veces - 0x4F -> 28 veces - 0x38 -> 25 veces - 0x49 -> 18 veces - 0xAB -> 12 veces - -Offset 0x025DC (9692): - Valores distintos (3): 0x01, 0x03, 0x06 - Clasificación: small_state - Más frecuentes: - 0x06 -> 214 veces - 0x01 -> 18 veces - 0x03 -> 2 veces - -Offset 0x025DD (9693): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 233 veces - 0x01 -> 1 veces - -Offset 0x025DE (9694): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 232 veces - 0x01 -> 2 veces - -Offset 0x025DF (9695): - Valores distintos (7): 0x03, 0x09, 0x0B, 0x0C, 0x0D, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 108 veces - 0x09 -> 43 veces - 0x03 -> 41 veces - 0x0D -> 13 veces - 0x0B -> 10 veces - -Offset 0x025E0 (9696): - Valores distintos (29): 0x34, 0x3C, 0x41, 0x45, 0x49, 0x50, 0x56, 0x5A, 0x5B, 0x65, 0x6A, 0x6E, 0x71, 0x76, 0x7C, 0x82, 0x89, 0x8E, 0x90, 0x96, 0x9B, 0xA4, 0xAC, 0xAD, 0xB2, 0xB4, 0xBA, 0xBD, 0xBF - Clasificación: bitfield_like - Más frecuentes: - 0x34 -> 46 veces - 0x65 -> 28 veces - 0x49 -> 26 veces - 0x5A -> 18 veces - 0xBF -> 18 veces - -Offset 0x025E2 (9698): - Valores distintos (26): 0x28, 0x30, 0x35, 0x38, 0x3E, 0x43, 0x49, 0x4F, 0x53, 0x56, 0x5A, 0x5C, 0x5D, 0x62, 0x65, 0x69, 0x6E, 0x70, 0x78, 0x7B, 0x88, 0x8C, 0x99, 0xA6, 0xAB, 0xB1 - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 46 veces - 0x4F -> 29 veces - 0x38 -> 26 veces - 0x49 -> 18 veces - 0xAB -> 14 veces - -Offset 0x025E4 (9700): - Valores distintos (31): 0x02, 0x05, 0x0A, 0x0F, 0x10, 0x1A, 0x26, 0x2F, 0x36, 0x56, 0x58, 0x5B, 0x5C, 0x5F, 0x61, 0x65, 0x6A, 0x6B, 0x83, 0x91, 0x9B, 0x9C, 0x9E, 0xA0, 0xA6, 0xB2, 0xB5, 0xB9, 0xBB, 0xBE, 0xC2 - Clasificación: bitfield_like - Más frecuentes: - 0x58 -> 46 veces - 0x65 -> 26 veces - 0x5B -> 20 veces - 0x83 -> 18 veces - 0x9B -> 15 veces - -Offset 0x025E5 (9701): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 180 veces - 0x01 -> 54 veces - -Offset 0x025E6 (9702): - Valores distintos (30): 0x21, 0x28, 0x2D, 0x31, 0x38, 0x39, 0x3C, 0x3D, 0x40, 0x4B, 0x4D, 0x4E, 0x64, 0x6C, 0x7B, 0x7F, 0x83, 0x86, 0x87, 0x88, 0x8E, 0x91, 0x93, 0x99, 0x9B, 0xA7, 0xAD, 0xBB, 0xBD, 0xC2 - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 46 veces - 0xC2 -> 20 veces - 0x3C -> 19 veces - 0x4E -> 18 veces - 0x6C -> 15 veces - -Offset 0x025E8 (9704): - Valores distintos (24): 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x12, 0x13, 0x17, 0x18, 0x19, 0x1B, 0x1C, 0x1D, 0x1E, 0x21, 0x22, 0x24, 0x28, 0x2B, 0x30, 0x35, 0x38, 0x3A - Clasificación: bitfield_like - Más frecuentes: - 0x0A -> 46 veces - 0x0E -> 43 veces - 0x13 -> 16 veces - 0x38 -> 14 veces - 0x0B -> 11 veces - -Offset 0x025EA (9706): - Valores distintos (28): 0x32, 0x39, 0x3C, 0x3F, 0x49, 0x4F, 0x54, 0x61, 0x66, 0x6A, 0x71, 0x76, 0x79, 0x7C, 0x83, 0x88, 0x91, 0x9C, 0xA0, 0xA6, 0xA9, 0xAB, 0xBA, 0xC1, 0xCF, 0xDC, 0xE3, 0xE6 - Clasificación: bitfield_like - Más frecuentes: - 0x32 -> 46 veces - 0x3F -> 33 veces - 0x61 -> 29 veces - 0x54 -> 18 veces - 0xE3 -> 14 veces - -Offset 0x025EF (9711): - Valores distintos (3): 0x02, 0x04, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 145 veces - 0x07 -> 88 veces - 0x04 -> 1 veces - -Offset 0x025F0 (9712): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 207 veces - 0x07 -> 27 veces - -Offset 0x025F1 (9713): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 207 veces - 0x07 -> 27 veces - -Offset 0x025F5 (9717): - Valores distintos (3): 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x02 -> 190 veces - 0x04 -> 24 veces - 0x06 -> 20 veces - -Offset 0x025F6 (9718): - Valores distintos (3): 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x02 -> 158 veces - 0x04 -> 56 veces - 0x06 -> 20 veces - -Offset 0x025F7 (9719): - Valores distintos (3): 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x02 -> 190 veces - 0x04 -> 24 veces - 0x06 -> 20 veces - -Offset 0x025F8 (9720): - Valores distintos (2): 0x1E, 0x28 - Clasificación: small_state - Más frecuentes: - 0x1E -> 194 veces - 0x28 -> 40 veces - -Offset 0x025FB (9723): - Valores distintos (2): 0x04, 0x09 - Clasificación: small_state - Más frecuentes: - 0x04 -> 194 veces - 0x09 -> 40 veces - -Offset 0x025FC (9724): - Valores distintos (2): 0x46, 0x4B - Clasificación: small_state - Más frecuentes: - 0x46 -> 194 veces - 0x4B -> 40 veces - -Offset 0x02600 (9728): - Valores distintos (27): 0x34, 0x3C, 0x41, 0x45, 0x49, 0x50, 0x56, 0x5A, 0x65, 0x6A, 0x6E, 0x71, 0x76, 0x7C, 0x82, 0x89, 0x8E, 0x90, 0x96, 0x9B, 0xA4, 0xAD, 0xB2, 0xB4, 0xBA, 0xBD, 0xBF - Clasificación: bitfield_like - Más frecuentes: - 0x34 -> 46 veces - 0x65 -> 29 veces - 0x49 -> 26 veces - 0xBF -> 19 veces - 0x5A -> 18 veces - -Offset 0x02602 (9730): - Valores distintos (26): 0x28, 0x30, 0x35, 0x38, 0x3E, 0x43, 0x49, 0x4F, 0x53, 0x56, 0x5A, 0x5C, 0x5D, 0x62, 0x65, 0x69, 0x6E, 0x70, 0x78, 0x7B, 0x88, 0x8C, 0x99, 0xA6, 0xAB, 0xB1 - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 46 veces - 0x4F -> 29 veces - 0x38 -> 26 veces - 0x49 -> 18 veces - 0xAB -> 14 veces - -Offset 0x02604 (9732): - Valores distintos (28): 0x1E, 0x21, 0x25, 0x27, 0x2B, 0x30, 0x31, 0x35, 0x41, 0x46, 0x4C, 0x4E, 0x52, 0x55, 0x59, 0x5B, 0x5E, 0x62, 0x64, 0x67, 0x6C, 0x6D, 0x77, 0x7B, 0x84, 0x8B, 0x90, 0x91 - Clasificación: bitfield_like - Más frecuentes: - 0x1E -> 46 veces - 0x41 -> 29 veces - 0x2B -> 26 veces - 0x35 -> 18 veces - 0x90 -> 14 veces - -Offset 0x02606 (9734): - Valores distintos (22): 0x19, 0x1B, 0x1D, 0x1E, 0x21, 0x24, 0x26, 0x27, 0x2D, 0x2F, 0x33, 0x36, 0x37, 0x38, 0x3A, 0x3D, 0x3F, 0x42, 0x44, 0x4A, 0x4F, 0x51 - Clasificación: bitfield_like - Más frecuentes: - 0x19 -> 46 veces - 0x2D -> 29 veces - 0x51 -> 29 veces - 0x21 -> 26 veces - 0x27 -> 18 veces - -Offset 0x02608 (9736): - Valores distintos (22): 0x0F, 0x11, 0x12, 0x14, 0x15, 0x16, 0x1C, 0x1E, 0x1F, 0x21, 0x22, 0x23, 0x24, 0x27, 0x28, 0x2A, 0x2E, 0x31, 0x36, 0x3B, 0x3E, 0x40 - Clasificación: bitfield_like - Más frecuentes: - 0x0F -> 46 veces - 0x1C -> 29 veces - 0x14 -> 26 veces - 0x16 -> 18 veces - 0x3E -> 14 veces - -Offset 0x0260A (9738): - Valores distintos (27): 0x32, 0x39, 0x3C, 0x3F, 0x49, 0x4F, 0x54, 0x61, 0x66, 0x6A, 0x71, 0x76, 0x79, 0x7C, 0x83, 0x88, 0x91, 0x97, 0x9B, 0xA6, 0xA9, 0xBA, 0xC1, 0xCF, 0xDC, 0xE3, 0xE6 - Clasificación: bitfield_like - Más frecuentes: - 0x32 -> 46 veces - 0x3F -> 33 veces - 0x61 -> 29 veces - 0x54 -> 18 veces - 0xE3 -> 14 veces - -Offset 0x02622 (9762): - Valores distintos (2): 0x00, 0x47 - Clasificación: small_state - Más frecuentes: - 0x47 -> 139 veces - 0x00 -> 95 veces - -Offset 0x02623 (9763): - Valores distintos (2): 0x00, 0x73 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x73 -> 85 veces - -Offset 0x02624 (9764): - Valores distintos (2): 0x00, 0x4C - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0x4C -> 75 veces - -Offset 0x02625 (9765): - Valores distintos (2): 0x00, 0x49 - Clasificación: small_state - Más frecuentes: - 0x00 -> 181 veces - 0x49 -> 53 veces - -Offset 0x02626 (9766): - Valores distintos (2): 0x00, 0x48 - Clasificación: small_state - Más frecuentes: - 0x00 -> 190 veces - 0x48 -> 44 veces - -Offset 0x0262E (9774): - Valores distintos (2): 0x00, 0x6B - Clasificación: small_state - Más frecuentes: - 0x6B -> 188 veces - 0x00 -> 46 veces - -Offset 0x0262F (9775): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x6C -> 177 veces - 0x00 -> 57 veces - -Offset 0x02630 (9776): - Valores distintos (2): 0x00, 0x54 - Clasificación: small_state - Más frecuentes: - 0x54 -> 144 veces - 0x00 -> 90 veces - -Offset 0x02631 (9777): - Valores distintos (2): 0x00, 0x55 - Clasificación: small_state - Más frecuentes: - 0x55 -> 121 veces - 0x00 -> 113 veces - -Offset 0x02634 (9780): - Valores distintos (2): 0x00, 0x66 - Clasificación: small_state - Más frecuentes: - 0x66 -> 182 veces - 0x00 -> 52 veces - -Offset 0x02635 (9781): - Valores distintos (2): 0x00, 0x6E - Clasificación: small_state - Más frecuentes: - 0x00 -> 161 veces - 0x6E -> 73 veces - -Offset 0x0263E (9790): - Valores distintos (2): 0x00, 0xA6 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0xA6 -> 92 veces - -Offset 0x0263F (9791): - Valores distintos (2): 0x00, 0xAD - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0xAD -> 92 veces - -Offset 0x02640 (9792): - Valores distintos (2): 0x00, 0xD8 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0xD8 -> 92 veces - -Offset 0x02641 (9793): - Valores distintos (2): 0x00, 0x45 - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x45 -> 82 veces - -Offset 0x02642 (9794): - Valores distintos (2): 0x00, 0x9E - Clasificación: small_state - Más frecuentes: - 0x00 -> 205 veces - 0x9E -> 29 veces - -Offset 0x02648 (9800): - Valores distintos (8): 0x00, 0x13, 0x17, 0x1B, 0x1E, 0x21, 0x24, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0x13 -> 41 veces - 0x2A -> 29 veces - 0x24 -> 14 veces - 0x1E -> 13 veces - -Offset 0x02649 (9801): - Valores distintos (4): 0x00, 0x01, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0xFD -> 43 veces - 0xFF -> 41 veces - 0x01 -> 10 veces - -Offset 0x0264A (9802): - Valores distintos (3): 0x00, 0x03, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 150 veces - 0x03 -> 43 veces - 0xFE -> 41 veces - -Offset 0x0264B (9803): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 140 veces - 0x01 -> 94 veces - -Offset 0x0264C (9804): - Valores distintos (3): 0x00, 0x01, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 182 veces - 0xFD -> 43 veces - 0x01 -> 9 veces - -Offset 0x0264D (9805): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 150 veces - 0x01 -> 84 veces - -Offset 0x0264E (9806): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 178 veces - 0x03 -> 43 veces - 0x01 -> 13 veces - -Offset 0x0266E (9838): - Valores distintos (19): 0x01, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14 - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 59 veces - 0x01 -> 52 veces - 0x13 -> 50 veces - 0x14 -> 25 veces - 0x11 -> 23 veces - -Offset 0x0266F (9839): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 161 veces - 0x00 -> 73 veces - -Offset 0x02670 (9840): - Valores distintos (27): 0x00, 0x0B, 0x19, 0x1D, 0x1F, 0x3C, 0x46, 0x47, 0x49, 0x55, 0x56, 0x58, 0x5A, 0x5E, 0x61, 0x73, 0x8D, 0x91, 0x93, 0xA9, 0xCC, 0xE7, 0xEB, 0xEC, 0xEE, 0xF1, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 52 veces - 0x0B -> 48 veces - 0x47 -> 40 veces - 0xEB -> 23 veces - 0x5A -> 23 veces - -Offset 0x02671 (9841): - Valores distintos (19): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x0C, 0x0E, 0x10, 0x14, 0x15, 0x16, 0x1E, 0x1F, 0x25, 0x31, 0x32, 0x33 - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 58 veces - 0x00 -> 55 veces - 0x31 -> 40 veces - 0x33 -> 25 veces - 0x1F -> 23 veces - -Offset 0x02675 (9845): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 230 veces - 0x20 -> 4 veces - -Offset 0x02676 (9846): - Valores distintos (3): 0x00, 0x3A, 0x3C - Clasificación: small_state - Más frecuentes: - 0x00 -> 117 veces - 0x3C -> 77 veces - 0x3A -> 40 veces - -Offset 0x02677 (9847): - Valores distintos (4): 0x00, 0x33, 0x36, 0x37 - Clasificación: small_state - Más frecuentes: - 0x37 -> 77 veces - 0x33 -> 69 veces - 0x00 -> 52 veces - 0x36 -> 36 veces - -Offset 0x02678 (9848): - Valores distintos (3): 0x00, 0x21, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 117 veces - 0x26 -> 113 veces - 0x21 -> 4 veces - -Offset 0x02679 (9849): - Valores distintos (3): 0x00, 0x08, 0x0B - Clasificación: small_state - Más frecuentes: - 0x0B -> 117 veces - 0x08 -> 65 veces - 0x00 -> 52 veces - -Offset 0x0267A (9850): - Valores distintos (4): 0x00, 0x02, 0x0B, 0x0E - Clasificación: small_state - Más frecuentes: - 0x00 -> 145 veces - 0x02 -> 77 veces - 0x0B -> 8 veces - 0x0E -> 4 veces - -Offset 0x0267B (9851): - Valores distintos (3): 0x00, 0x01, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 124 veces - 0x01 -> 77 veces - 0x0A -> 33 veces - -Offset 0x0267C (9852): - Valores distintos (23): 0x01, 0x13, 0x1C, 0x1E, 0x21, 0x27, 0x28, 0x2A, 0x39, 0x43, 0x48, 0x54, 0x6D, 0x7A, 0x7F, 0x81, 0x86, 0x91, 0x97, 0xAC, 0xC8, 0xC9, 0xD1 - Clasificación: bitfield_like - Más frecuentes: - 0x54 -> 58 veces - 0x28 -> 52 veces - 0xC9 -> 50 veces - 0xD1 -> 24 veces - 0xAC -> 22 veces - -Offset 0x0267E (9854): - Valores distintos (16): 0x08, 0x0C, 0x10, 0x17, 0x1A, 0x1B, 0x21, 0x24, 0x28, 0x2A, 0x2F, 0x33, 0x36, 0x3C, 0x43, 0x46 - Clasificación: bitfield_like - Más frecuentes: - 0x24 -> 59 veces - 0x08 -> 53 veces - 0x43 -> 51 veces - 0x3C -> 24 veces - 0x46 -> 24 veces - -Offset 0x02682 (9858): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 227 veces - 0x03 -> 2 veces - 0x05 -> 2 veces - 0x02 -> 1 veces - 0x04 -> 1 veces - -Offset 0x02683 (9859): - Valores distintos (3): 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 126 veces - 0x02 -> 56 veces - 0xFF -> 52 veces - -Offset 0x02684 (9860): - Valores distintos (22): 0x28, 0x2D, 0x30, 0x37, 0x3D, 0x3E, 0x40, 0x42, 0x43, 0x48, 0x4B, 0x4D, 0x50, 0x54, 0x7A, 0x81, 0x91, 0x9A, 0xAC, 0xBF, 0xC9, 0xD1 - Clasificación: bitfield_like - Más frecuentes: - 0x54 -> 59 veces - 0x28 -> 52 veces - 0xC9 -> 50 veces - 0xD1 -> 25 veces - 0xAC -> 23 veces - -Offset 0x02686 (9862): - Valores distintos (17): 0x08, 0x0C, 0x10, 0x17, 0x1A, 0x1B, 0x21, 0x24, 0x28, 0x2A, 0x2F, 0x30, 0x33, 0x36, 0x3C, 0x43, 0x46 - Clasificación: bitfield_like - Más frecuentes: - 0x24 -> 59 veces - 0x08 -> 52 veces - 0x43 -> 52 veces - 0x46 -> 25 veces - 0x3C -> 23 veces - -Offset 0x02688 (9864): - Valores distintos (16): 0x12, 0x13, 0x17, 0x1C, 0x35, 0x39, 0x3E, 0x41, 0x49, 0x4B, 0x4F, 0x53, 0x5B, 0x81, 0x84, 0x88 - Clasificación: bitfield_like - Más frecuentes: - 0x1C -> 60 veces - 0x12 -> 53 veces - 0x84 -> 50 veces - 0x88 -> 25 veces - 0x5B -> 23 veces - -Offset 0x0268A (9866): - Valores distintos (21): 0x0E, 0x24, 0x27, 0x2D, 0x2F, 0x30, 0x37, 0x3A, 0x3E, 0x44, 0x47, 0x4D, 0x5B, 0x64, 0x69, 0x6C, 0x72, 0x7B, 0x8D, 0x92, 0x98 - Clasificación: bitfield_like - Más frecuentes: - 0x3A -> 58 veces - 0x0E -> 52 veces - 0x92 -> 50 veces - 0x98 -> 25 veces - 0x7B -> 23 veces - -Offset 0x0268C (9868): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x03 -> 112 veces - 0x01 -> 77 veces - 0x02 -> 38 veces - 0x04 -> 4 veces - 0x00 -> 3 veces - -Offset 0x0268E (9870): - Valores distintos (9): 0x04, 0x08, 0x0A, 0x0F, 0x11, 0x13, 0x1A, 0x1C, 0x1F - Clasificación: bitfield_like - Más frecuentes: - 0x1F -> 111 veces - 0x1C -> 64 veces - 0x04 -> 52 veces - 0x1A -> 2 veces - 0x08 -> 1 veces - -Offset 0x02693 (9875): - Valores distintos (3): 0x01, 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 170 veces - 0x01 -> 56 veces - 0x07 -> 8 veces - -Offset 0x02694 (9876): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 201 veces - 0x07 -> 33 veces - -Offset 0x0269B (9883): - Valores distintos (2): 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x04 -> 230 veces - 0x06 -> 4 veces - -Offset 0x026A4 (9892): - Valores distintos (19): 0x28, 0x2D, 0x30, 0x3D, 0x3E, 0x43, 0x50, 0x54, 0x5E, 0x67, 0x6E, 0x81, 0x88, 0x91, 0x9A, 0xAC, 0xBF, 0xC9, 0xD1 - Clasificación: bitfield_like - Más frecuentes: - 0x54 -> 59 veces - 0x28 -> 52 veces - 0xC9 -> 50 veces - 0xD1 -> 25 veces - 0xAC -> 23 veces - -Offset 0x026A6 (9894): - Valores distintos (17): 0x08, 0x0C, 0x10, 0x17, 0x1A, 0x1B, 0x21, 0x24, 0x28, 0x2A, 0x2F, 0x30, 0x33, 0x36, 0x3C, 0x43, 0x46 - Clasificación: bitfield_like - Más frecuentes: - 0x24 -> 59 veces - 0x08 -> 52 veces - 0x43 -> 52 veces - 0x46 -> 25 veces - 0x3C -> 23 veces - -Offset 0x026A8 (9896): - Valores distintos (15): 0x12, 0x13, 0x17, 0x1C, 0x20, 0x25, 0x28, 0x30, 0x32, 0x36, 0x3A, 0x42, 0x49, 0x4C, 0x50 - Clasificación: bitfield_like - Más frecuentes: - 0x1C -> 61 veces - 0x12 -> 53 veces - 0x4C -> 50 veces - 0x50 -> 25 veces - 0x42 -> 23 veces - -Offset 0x026AA (9898): - Valores distintos (19): 0x0E, 0x11, 0x14, 0x1A, 0x1C, 0x1D, 0x24, 0x27, 0x2D, 0x30, 0x36, 0x3F, 0x44, 0x47, 0x4D, 0x56, 0x5E, 0x63, 0x69 - Clasificación: bitfield_like - Más frecuentes: - 0x27 -> 59 veces - 0x0E -> 52 veces - 0x63 -> 50 veces - 0x69 -> 25 veces - 0x56 -> 23 veces - -Offset 0x026AC (9900): - Valores distintos (5): 0x03, 0x04, 0x05, 0x07, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 177 veces - 0x03 -> 52 veces - 0x05 -> 2 veces - 0x07 -> 2 veces - 0x04 -> 1 veces - -Offset 0x026AE (9902): - Valores distintos (9): 0x04, 0x08, 0x0A, 0x0F, 0x11, 0x13, 0x1A, 0x1C, 0x1F - Clasificación: bitfield_like - Más frecuentes: - 0x1F -> 111 veces - 0x1C -> 64 veces - 0x04 -> 52 veces - 0x1A -> 2 veces - 0x08 -> 1 veces - -Offset 0x026C4 (9924): - Valores distintos (2): 0x00, 0x47 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x47 -> 25 veces - -Offset 0x026CE (9934): - Valores distintos (2): 0x00, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 118 veces - 0x30 -> 116 veces - -Offset 0x026CF (9935): - Valores distintos (2): 0x00, 0x33 - Clasificación: small_state - Más frecuentes: - 0x00 -> 134 veces - 0x33 -> 100 veces - -Offset 0x026E2 (9954): - Valores distintos (2): 0x00, 0x3A - Clasificación: small_state - Más frecuentes: - 0x3A -> 179 veces - 0x00 -> 55 veces - -Offset 0x026E3 (9955): - Valores distintos (2): 0x00, 0x24 - Clasificación: small_state - Más frecuentes: - 0x24 -> 178 veces - 0x00 -> 56 veces - -Offset 0x026E4 (9956): - Valores distintos (2): 0x00, 0xB9 - Clasificación: small_state - Más frecuentes: - 0xB9 -> 175 veces - 0x00 -> 59 veces - -Offset 0x026EC (9964): - Valores distintos (3): 0x00, 0x01, 0x09 - Clasificación: small_state - Más frecuentes: - 0x09 -> 126 veces - 0x01 -> 56 veces - 0x00 -> 52 veces - -Offset 0x026ED (9965): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 126 veces - 0xFF -> 56 veces - 0x00 -> 52 veces - -Offset 0x026EE (9966): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 178 veces - 0x01 -> 56 veces - -Offset 0x026EF (9967): - Valores distintos (3): 0x00, 0x01, 0xFE - Clasificación: small_state - Más frecuentes: - 0x01 -> 126 veces - 0xFE -> 56 veces - 0x00 -> 52 veces - -Offset 0x026F0 (9968): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 126 veces - 0x01 -> 56 veces - 0x00 -> 52 veces - -Offset 0x026F1 (9969): - Valores distintos (2): 0x00, 0xFD - Clasificación: small_state - Más frecuentes: - 0xFD -> 126 veces - 0x00 -> 108 veces - -Offset 0x026F2 (9970): - Valores distintos (3): 0x00, 0x02, 0xFD - Clasificación: small_state - Más frecuentes: - 0xFD -> 126 veces - 0x02 -> 56 veces - 0x00 -> 52 veces - -Offset 0x0271A (10010): - Valores distintos (2): 0x00, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 152 veces - 0x00 -> 82 veces - -Offset 0x0271D (10013): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x0A -> 152 veces - 0x00 -> 82 veces - -Offset 0x02720 (10016): - Valores distintos (7): 0x07, 0x0F, 0x32, 0x42, 0x53, 0x67, 0x77 - Clasificación: small_state - Más frecuentes: - 0x77 -> 147 veces - 0x0F -> 63 veces - 0x32 -> 13 veces - 0x07 -> 7 veces - 0x67 -> 2 veces - -Offset 0x02728 (10024): - Valores distintos (6): 0x0F, 0x32, 0x42, 0x53, 0x67, 0x77 - Clasificación: small_state - Más frecuentes: - 0x77 -> 149 veces - 0x0F -> 70 veces - 0x32 -> 12 veces - 0x42 -> 1 veces - 0x53 -> 1 veces - -Offset 0x0272C (10028): - Valores distintos (6): 0x0A, 0x1E, 0x55, 0x63, 0x6F, 0x75 - Clasificación: small_state - Más frecuentes: - 0x75 -> 149 veces - 0x0A -> 70 veces - 0x1E -> 12 veces - 0x55 -> 1 veces - 0x63 -> 1 veces - -Offset 0x0272E (10030): - Valores distintos (4): 0x08, 0x18, 0x41, 0x54 - Clasificación: small_state - Más frecuentes: - 0x54 -> 150 veces - 0x08 -> 70 veces - 0x18 -> 12 veces - 0x41 -> 2 veces - -Offset 0x02730 (10032): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 164 veces - 0x04 -> 70 veces - -Offset 0x02732 (10034): - Valores distintos (2): 0x08, 0x0C - Clasificación: small_state - Más frecuentes: - 0x0C -> 164 veces - 0x08 -> 70 veces - -Offset 0x02748 (10056): - Valores distintos (6): 0x0F, 0x32, 0x42, 0x53, 0x67, 0x77 - Clasificación: small_state - Más frecuentes: - 0x77 -> 149 veces - 0x0F -> 70 veces - 0x32 -> 12 veces - 0x42 -> 1 veces - 0x53 -> 1 veces - -Offset 0x0274C (10060): - Valores distintos (6): 0x0A, 0x1E, 0x2A, 0x38, 0x44, 0x4A - Clasificación: small_state - Más frecuentes: - 0x4A -> 149 veces - 0x0A -> 70 veces - 0x1E -> 12 veces - 0x2A -> 1 veces - 0x38 -> 1 veces - -Offset 0x0274E (10062): - Valores distintos (4): 0x08, 0x18, 0x2C, 0x3F - Clasificación: small_state - Más frecuentes: - 0x3F -> 150 veces - 0x08 -> 70 veces - 0x18 -> 12 veces - 0x2C -> 2 veces - -Offset 0x02750 (10064): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 164 veces - 0x04 -> 70 veces - -Offset 0x02752 (10066): - Valores distintos (2): 0x08, 0x0C - Clasificación: small_state - Más frecuentes: - 0x0C -> 164 veces - 0x08 -> 70 veces - -Offset 0x02786 (10118): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 148 veces - 0x03 -> 86 veces - -Offset 0x027B8 (10168): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 224 veces - 0x03 -> 10 veces - -Offset 0x027B9 (10169): - Valores distintos (2): 0x00, 0xBE - Clasificación: small_state - Más frecuentes: - 0xBE -> 222 veces - 0x00 -> 12 veces - -Offset 0x027BA (10170): - Valores distintos (2): 0x00, 0x74 - Clasificación: small_state - Más frecuentes: - 0x74 -> 222 veces - 0x00 -> 12 veces - -Offset 0x027BB (10171): - Valores distintos (4): 0x00, 0x1E, 0x1F, 0x3F - Clasificación: small_state - Más frecuentes: - 0x3F -> 222 veces - 0x00 -> 5 veces - 0x1F -> 5 veces - 0x1E -> 2 veces - -Offset 0x027BF (10175): - Valores distintos (3): 0x00, 0x1E, 0x5E - Clasificación: small_state - Más frecuentes: - 0x5E -> 219 veces - 0x00 -> 12 veces - 0x1E -> 3 veces - -Offset 0x027C0 (10176): - Valores distintos (3): 0x00, 0xF1, 0xFB - Clasificación: small_state - Más frecuentes: - 0xFB -> 214 veces - 0x00 -> 15 veces - 0xF1 -> 5 veces - -Offset 0x027C1 (10177): - Valores distintos (2): 0x00, 0x91 - Clasificación: small_state - Más frecuentes: - 0x91 -> 219 veces - 0x00 -> 15 veces - -Offset 0x027C2 (10178): - Valores distintos (4): 0x00, 0x01, 0x9F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 214 veces - 0x00 -> 15 veces - 0x9F -> 4 veces - 0x01 -> 1 veces - -Offset 0x027C3 (10179): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 214 veces - 0x00 -> 16 veces - 0x01 -> 4 veces - -Offset 0x027C4 (10180): - Valores distintos (3): 0x00, 0xF0, 0xF1 - Clasificación: small_state - Más frecuentes: - 0xF1 -> 214 veces - 0x00 -> 15 veces - 0xF0 -> 5 veces - -Offset 0x027C5 (10181): - Valores distintos (2): 0x00, 0xC2 - Clasificación: small_state - Más frecuentes: - 0xC2 -> 219 veces - 0x00 -> 15 veces - -Offset 0x027C6 (10182): - Valores distintos (3): 0x00, 0x0F, 0xCF - Clasificación: small_state - Más frecuentes: - 0xCF -> 214 veces - 0x00 -> 15 veces - 0x0F -> 5 veces - -Offset 0x027C7 (10183): - Valores distintos (3): 0x00, 0xC4, 0xC5 - Clasificación: small_state - Más frecuentes: - 0xC5 -> 214 veces - 0x00 -> 15 veces - 0xC4 -> 5 veces - -Offset 0x027C8 (10184): - Valores distintos (2): 0x00, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 192 veces - 0x00 -> 42 veces - -Offset 0x027C9 (10185): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 192 veces - 0x00 -> 42 veces - -Offset 0x027CA (10186): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 192 veces - 0x00 -> 42 veces - -Offset 0x027CB (10187): - Valores distintos (2): 0x00, 0x7F - Clasificación: small_state - Más frecuentes: - 0x7F -> 192 veces - 0x00 -> 42 veces - -Offset 0x027D0 (10192): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 188 veces - 0x00 -> 43 veces - 0x03 -> 3 veces - -Offset 0x027D1 (10193): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x15 -> 188 veces - 0x00 -> 46 veces - -Offset 0x027D8 (10200): - Valores distintos (3): 0x00, 0x07, 0x67 - Clasificación: small_state - Más frecuentes: - 0x67 -> 182 veces - 0x00 -> 50 veces - 0x07 -> 2 veces - -Offset 0x027D9 (10201): - Valores distintos (3): 0x00, 0x03, 0xDF - Clasificación: small_state - Más frecuentes: - 0xDF -> 172 veces - 0x00 -> 52 veces - 0x03 -> 10 veces - -Offset 0x027DA (10202): - Valores distintos (2): 0x00, 0x9F - Clasificación: small_state - Más frecuentes: - 0x9F -> 172 veces - 0x00 -> 62 veces - -Offset 0x027DB (10203): - Valores distintos (3): 0x00, 0x07, 0xE7 - Clasificación: small_state - Más frecuentes: - 0xE7 -> 164 veces - 0x00 -> 62 veces - 0x07 -> 8 veces - -Offset 0x027DC (10204): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 164 veces - 0x00 -> 70 veces - -Offset 0x027DD (10205): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 164 veces - 0x00 -> 70 veces - -Offset 0x027DE (10206): - Valores distintos (2): 0x00, 0x37 - Clasificación: small_state - Más frecuentes: - 0x37 -> 164 veces - 0x00 -> 70 veces - -Offset 0x027DF (10207): - Valores distintos (2): 0x00, 0x78 - Clasificación: small_state - Más frecuentes: - 0x78 -> 164 veces - 0x00 -> 70 veces - -Offset 0x027E0 (10208): - Valores distintos (3): 0x00, 0x03, 0xFB - Clasificación: small_state - Más frecuentes: - 0xFB -> 158 veces - 0x00 -> 71 veces - 0x03 -> 5 veces - -Offset 0x027E1 (10209): - Valores distintos (4): 0x00, 0x0F, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 153 veces - 0x00 -> 76 veces - 0x0F -> 4 veces - 0x1F -> 1 veces - -Offset 0x027E2 (10210): - Valores distintos (3): 0x00, 0x1F, 0x7F - Clasificación: small_state - Más frecuentes: - 0x7F -> 152 veces - 0x00 -> 81 veces - 0x1F -> 1 veces - -Offset 0x027E3 (10211): - Valores distintos (3): 0x00, 0x1C, 0xFC - Clasificación: small_state - Más frecuentes: - 0xFC -> 147 veces - 0x00 -> 82 veces - 0x1C -> 5 veces - -Offset 0x027E4 (10212): - Valores distintos (3): 0x00, 0x0E, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 144 veces - 0x00 -> 87 veces - 0x0E -> 3 veces - -Offset 0x027E5 (10213): - Valores distintos (2): 0x00, 0x17 - Clasificación: small_state - Más frecuentes: - 0x17 -> 144 veces - 0x00 -> 90 veces - -Offset 0x027E7 (10215): - Valores distintos (5): 0x00, 0x30, 0x38, 0xB8, 0xF8 - Clasificación: small_state - Más frecuentes: - 0xF8 -> 118 veces - 0x00 -> 77 veces - 0xB8 -> 26 veces - 0x38 -> 9 veces - 0x30 -> 4 veces - -Offset 0x027E8 (10216): - Valores distintos (4): 0x00, 0x07, 0x0F, 0xDF - Clasificación: small_state - Más frecuentes: - 0xDF -> 139 veces - 0x00 -> 91 veces - 0x07 -> 2 veces - 0x0F -> 2 veces - -Offset 0x027E9 (10217): - Valores distintos (3): 0x00, 0x18, 0x1B - Clasificación: small_state - Más frecuentes: - 0x1B -> 139 veces - 0x00 -> 92 veces - 0x18 -> 3 veces - -Offset 0x027F0 (10224): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 136 veces - 0x00 -> 95 veces - 0x0F -> 3 veces - -Offset 0x027F1 (10225): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 133 veces - 0x00 -> 99 veces - 0x01 -> 2 veces - -Offset 0x027F2 (10226): - Valores distintos (5): 0x00, 0x40, 0x41, 0x5B, 0x7B - Clasificación: small_state - Más frecuentes: - 0x7B -> 130 veces - 0x00 -> 100 veces - 0x41 -> 2 veces - 0x40 -> 1 veces - 0x5B -> 1 veces - -Offset 0x027F3 (10227): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 133 veces - 0x00 -> 101 veces - -Offset 0x027F8 (10232): - Valores distintos (5): 0x00, 0x03, 0x1F, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 124 veces - 0x00 -> 105 veces - 0x1F -> 2 veces - 0x7F -> 2 veces - 0x03 -> 1 veces - -Offset 0x027F9 (10233): - Valores distintos (3): 0x00, 0x01, 0xF9 - Clasificación: small_state - Más frecuentes: - 0xF9 -> 121 veces - 0x00 -> 110 veces - 0x01 -> 3 veces - -Offset 0x027FA (10234): - Valores distintos (2): 0x00, 0xEF - Clasificación: small_state - Más frecuentes: - 0xEF -> 121 veces - 0x00 -> 113 veces - -Offset 0x027FB (10235): - Valores distintos (2): 0x00, 0x7F - Clasificación: small_state - Más frecuentes: - 0x7F -> 121 veces - 0x00 -> 113 veces - -Offset 0x027FC (10236): - Valores distintos (4): 0x00, 0xC0, 0xDC, 0xDF - Clasificación: small_state - Más frecuentes: - 0xDF -> 117 veces - 0x00 -> 110 veces - 0xC0 -> 6 veces - 0xDC -> 1 veces - -Offset 0x027FD (10237): - Valores distintos (3): 0x00, 0x10, 0xD0 - Clasificación: small_state - Más frecuentes: - 0xD0 -> 118 veces - 0x00 -> 113 veces - 0x10 -> 3 veces - -Offset 0x027FE (10238): - Valores distintos (2): 0x00, 0xD7 - Clasificación: small_state - Más frecuentes: - 0xD7 -> 118 veces - 0x00 -> 116 veces - -Offset 0x027FF (10239): - Valores distintos (5): 0x00, 0x40, 0x60, 0x67, 0xE7 - Clasificación: small_state - Más frecuentes: - 0xE7 -> 117 veces - 0x00 -> 110 veces - 0x40 -> 3 veces - 0x60 -> 3 veces - 0x67 -> 1 veces - -Offset 0x02800 (10240): - Valores distintos (3): 0x00, 0xF0, 0xF7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 131 veces - 0xF7 -> 96 veces - 0xF0 -> 7 veces - -Offset 0x02801 (10241): - Valores distintos (4): 0x00, 0x01, 0x6F, 0xEF - Clasificación: small_state - Más frecuentes: - 0x00 -> 131 veces - 0xEF -> 99 veces - 0x6F -> 3 veces - 0x01 -> 1 veces - -Offset 0x02802 (10242): - Valores distintos (5): 0x00, 0x08, 0x09, 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 132 veces - 0xFF -> 93 veces - 0x08 -> 6 veces - 0xFB -> 2 veces - 0x09 -> 1 veces - -Offset 0x02803 (10243): - Valores distintos (3): 0x00, 0x04, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 131 veces - 0x07 -> 93 veces - 0x04 -> 10 veces - -Offset 0x02804 (10244): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 138 veces - 0xFF -> 96 veces - -Offset 0x02805 (10245): - Valores distintos (3): 0x00, 0x1B, 0xDB - Clasificación: small_state - Más frecuentes: - 0x00 -> 138 veces - 0xDB -> 95 veces - 0x1B -> 1 veces - -Offset 0x02806 (10246): - Valores distintos (5): 0x00, 0x10, 0x30, 0x70, 0xF0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 117 veces - 0xF0 -> 105 veces - 0x30 -> 9 veces - 0x70 -> 2 veces - 0x10 -> 1 veces - -Offset 0x02807 (10247): - Valores distintos (3): 0x00, 0x07, 0x3F - Clasificación: small_state - Más frecuentes: - 0x00 -> 129 veces - 0x3F -> 104 veces - 0x07 -> 1 veces - -Offset 0x02808 (10248): - Valores distintos (4): 0x00, 0x17, 0x77, 0xF7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 141 veces - 0xF7 -> 91 veces - 0x17 -> 1 veces - 0x77 -> 1 veces - -Offset 0x02809 (10249): - Valores distintos (5): 0x00, 0x01, 0x03, 0x1F, 0xDF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0xDF -> 85 veces - 0x01 -> 42 veces - 0x03 -> 1 veces - 0x1F -> 1 veces - -Offset 0x0280A (10250): - Valores distintos (2): 0x00, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x0F -> 85 veces - -Offset 0x02810 (10256): - Valores distintos (3): 0x00, 0x01, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 153 veces - 0x07 -> 77 veces - 0x01 -> 4 veces - -Offset 0x02812 (10258): - Valores distintos (3): 0x00, 0xC0, 0xF0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 153 veces - 0xF0 -> 79 veces - 0xC0 -> 2 veces - -Offset 0x02813 (10259): - Valores distintos (2): 0x00, 0x43 - Clasificación: small_state - Más frecuentes: - 0x00 -> 153 veces - 0x43 -> 81 veces - -Offset 0x02814 (10260): - Valores distintos (2): 0x00, 0xF0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 155 veces - 0xF0 -> 79 veces - -Offset 0x02815 (10261): - Valores distintos (3): 0x00, 0x1F, 0xBF - Clasificación: small_state - Más frecuentes: - 0x00 -> 155 veces - 0xBF -> 77 veces - 0x1F -> 2 veces - -Offset 0x02816 (10262): - Valores distintos (3): 0x00, 0x40, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 155 veces - 0x41 -> 77 veces - 0x40 -> 2 veces - -Offset 0x02817 (10263): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 157 veces - 0x80 -> 77 veces - -Offset 0x02818 (10264): - Valores distintos (3): 0x00, 0x3D, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 157 veces - 0xFD -> 75 veces - 0x3D -> 2 veces - -Offset 0x02819 (10265): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0xFF -> 75 veces - -Offset 0x0281A (10266): - Valores distintos (4): 0x00, 0x01, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 160 veces - 0xFF -> 61 veces - 0x01 -> 9 veces - 0x7F -> 4 veces - -Offset 0x0281B (10267): - Valores distintos (4): 0x00, 0x83, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 173 veces - 0xFF -> 58 veces - 0xBF -> 2 veces - 0x83 -> 1 veces - -Offset 0x02820 (10272): - Valores distintos (3): 0x00, 0x01, 0xD1 - Clasificación: small_state - Más frecuentes: - 0x00 -> 183 veces - 0xD1 -> 47 veces - 0x01 -> 4 veces - -Offset 0x02821 (10273): - Valores distintos (4): 0x00, 0x1F, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0xFF -> 33 veces - 0x7F -> 11 veces - 0x1F -> 3 veces - -Offset 0x02822 (10274): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 190 veces - 0x03 -> 24 veces - 0xFF -> 20 veces - -Offset 0x02823 (10275): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0xFF -> 20 veces - -Offset 0x02826 (10278): - Valores distintos (3): 0x00, 0x20, 0x23 - Clasificación: small_state - Más frecuentes: - 0x00 -> 190 veces - 0x20 -> 24 veces - 0x23 -> 20 veces - -Offset 0x02828 (10280): - Valores distintos (3): 0x00, 0x01, 0x7F - Clasificación: small_state - Más frecuentes: - 0x00 -> 216 veces - 0x7F -> 10 veces - 0x01 -> 8 veces - -Offset 0x0282C (10284): - Valores distintos (6): 0x00, 0x02, 0x06, 0xCE, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 215 veces - 0xFF -> 14 veces - 0xEF -> 2 veces - 0x02 -> 1 veces - 0x06 -> 1 veces - -Offset 0x0282D (10285): - Valores distintos (7): 0x00, 0x90, 0x91, 0x95, 0x9D, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 215 veces - 0xFF -> 14 veces - 0x90 -> 1 veces - 0x91 -> 1 veces - 0x95 -> 1 veces - -Offset 0x02850 (10320): - Valores distintos (2): 0x08, 0xF8 - Clasificación: small_state - Más frecuentes: - 0xF8 -> 144 veces - 0x08 -> 90 veces - -Offset 0x02851 (10321): - Valores distintos (3): 0x00, 0x20, 0xE0 - Clasificación: small_state - Más frecuentes: - 0xE0 -> 136 veces - 0x20 -> 52 veces - 0x00 -> 46 veces - -Offset 0x02853 (10323): - Valores distintos (3): 0x07, 0x0A, 0x2F - Clasificación: small_state - Más frecuentes: - 0x2F -> 136 veces - 0x0A -> 96 veces - 0x07 -> 2 veces - -Offset 0x02854 (10324): - Valores distintos (2): 0x00, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 141 veces - 0x00 -> 93 veces - -Offset 0x02855 (10325): - Valores distintos (5): 0x00, 0x80, 0x84, 0x86, 0xE6 - Clasificación: small_state - Más frecuentes: - 0x00 -> 90 veces - 0xE6 -> 75 veces - 0x80 -> 63 veces - 0x86 -> 4 veces - 0x84 -> 2 veces - -Offset 0x02856 (10326): - Valores distintos (8): 0x00, 0x42, 0x4A, 0xCA, 0xCE, 0xDE, 0xEE, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0xDE -> 40 veces - 0x4A -> 37 veces - 0x42 -> 21 veces - 0xEE -> 19 veces - -Offset 0x02857 (10327): - Valores distintos (2): 0x00, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 160 veces - 0xFD -> 74 veces - -Offset 0x02858 (10328): - Valores distintos (6): 0x00, 0x08, 0x25, 0x29, 0x39, 0xB9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x29 -> 54 veces - 0xB9 -> 44 veces - 0x08 -> 21 veces - 0x25 -> 18 veces - -Offset 0x02859 (10329): - Valores distintos (4): 0x00, 0x20, 0x2A, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 170 veces - 0x2A -> 44 veces - 0x20 -> 11 veces - 0x80 -> 9 veces - -Offset 0x0285A (10330): - Valores distintos (4): 0x00, 0x01, 0x03, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 118 veces - 0x11 -> 54 veces - 0x01 -> 53 veces - 0x03 -> 9 veces - -Offset 0x0285B (10331): - Valores distintos (4): 0x00, 0x08, 0x18, 0x1E - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x1E -> 44 veces - 0x08 -> 31 veces - 0x18 -> 10 veces - -Offset 0x0285C (10332): - Valores distintos (3): 0x00, 0x3F, 0xBF - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0xBF -> 33 veces - 0x3F -> 21 veces - -Offset 0x0285D (10333): - Valores distintos (6): 0x00, 0x09, 0x69, 0xE9, 0xED, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0xE9 -> 52 veces - 0xFD -> 43 veces - 0x09 -> 16 veces - 0x69 -> 2 veces - -Offset 0x0285E (10334): - Valores distintos (6): 0x00, 0x04, 0x07, 0x0F, 0x80, 0x87 - Clasificación: small_state - Más frecuentes: - 0x00 -> 113 veces - 0x07 -> 65 veces - 0x0F -> 29 veces - 0x04 -> 22 veces - 0x80 -> 3 veces - -Offset 0x0285F (10335): - Valores distintos (4): 0x00, 0x80, 0xC2, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 104 veces - 0x80 -> 97 veces - 0xFE -> 20 veces - 0xC2 -> 13 veces - -Offset 0x02860 (10336): - Valores distintos (5): 0x00, 0x18, 0x1C, 0x5C, 0xDD - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x18 -> 71 veces - 0x1C -> 29 veces - 0xDD -> 10 veces - 0x5C -> 8 veces - -Offset 0x02861 (10337): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0x80 -> 43 veces - -Offset 0x02862 (10338): - Valores distintos (6): 0x00, 0x20, 0x23, 0x38, 0x3B, 0x3F - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x20 -> 45 veces - 0x38 -> 30 veces - 0x3B -> 27 veces - 0x3F -> 10 veces - -Offset 0x02863 (10339): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 148 veces - 0x01 -> 86 veces - -Offset 0x0286E (10350): - Valores distintos (4): 0x00, 0x40, 0xC0, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 119 veces - 0xE0 -> 74 veces - 0xC0 -> 33 veces - 0x40 -> 8 veces - -Offset 0x0286F (10351): - Valores distintos (7): 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 133 veces - 0xFF -> 43 veces - 0x0F -> 37 veces - 0x07 -> 17 veces - 0x01 -> 2 veces - -Offset 0x02878 (10360): - Valores distintos (120): 0x00, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0F, 0x10, 0x15, 0x16, 0x17, 0x1C, 0x1F, 0x21, 0x23, 0x29, 0x2A, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x37, 0x3A, 0x3C, 0x3F, 0x40, 0x45, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4F, 0x51, 0x52, 0x53, 0x57, 0x5A, 0x5D, 0x5E, 0x62, 0x64, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6E, 0x72, 0x73, 0x77, 0x78, 0x7C, 0x7E, 0x7F, 0x85, 0x87, 0x88, 0x89, 0x8B, 0x8D, 0x90, 0x92, 0x95, 0x96, 0x98, 0x9A, 0x9B, 0x9C, 0xA1, 0xA3, 0xA5, 0xA6, 0xA7, 0xAB, 0xAC, 0xAE, 0xAF, 0xB0, 0xB3, 0xB4, 0xB7, 0xB8, 0xBC, 0xBD, 0xBF, 0xC2, 0xC3, 0xC7, 0xCB, 0xCC, 0xCD, 0xD0, 0xD1, 0xD2, 0xD3, 0xDA, 0xDB, 0xDD, 0xDF, 0xE7, 0xE9, 0xEE, 0xEF, 0xF1, 0xF3, 0xF4, 0xF6, 0xF7, 0xF8, 0xFC, 0xFD, 0xFE - Clasificación: bitfield_like - Más frecuentes: - 0x45 -> 10 veces - 0xAC -> 6 veces - 0x67 -> 6 veces - 0x00 -> 5 veces - 0xCC -> 5 veces - -Offset 0x02879 (10361): - Valores distintos (86): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x28, 0x2B, 0x2C, 0x2F, 0x30, 0x32, 0x34, 0x35, 0x36, 0x37, 0x38, 0x3B, 0x3C, 0x3E, 0x3F, 0x41, 0x42, 0x47, 0x49, 0x4B, 0x4F, 0x55, 0x58, 0x59, 0x5C, 0x62, 0x63, 0x66, 0x67, 0x68, 0x69, 0x73, 0x75, 0x7E, 0x80, 0x89, 0x8C, 0x91, 0x92, 0x9E, 0xA0, 0xA4, 0xBE, 0xCA, 0xCE, 0xD2, 0xE2, 0xF2, 0xF8 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 14 veces - 0x06 -> 13 veces - 0x02 -> 12 veces - 0x1C -> 9 veces - 0x0A -> 8 veces - -Offset 0x0287A (10362): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 205 veces - 0x01 -> 21 veces - 0x02 -> 8 veces - -Offset 0x0287E (10366): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0x0A -> 1 veces - -Offset 0x0287F (10367): - Valores distintos (3): 0x00, 0x21, 0xF0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0xF0 -> 46 veces - 0x21 -> 1 veces - -Offset 0x02880 (10368): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 162 veces - 0x01 -> 61 veces - 0x03 -> 11 veces - -Offset 0x02881 (10369): - Valores distintos (4): 0x07, 0x0F, 0x2F, 0x3F - Clasificación: small_state - Más frecuentes: - 0x07 -> 159 veces - 0x3F -> 52 veces - 0x2F -> 13 veces - 0x0F -> 10 veces - -Offset 0x02882 (10370): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 124 veces - 0x00 -> 71 veces - 0x04 -> 9 veces - 0x01 -> 8 veces - 0x09 -> 5 veces - -Offset 0x02883 (10371): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 58 veces - 0x05 -> 41 veces - 0x02 -> 38 veces - 0xFF -> 27 veces - 0x00 -> 18 veces - -Offset 0x02884 (10372): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x05 -> 80 veces - 0xFF -> 44 veces - 0x08 -> 40 veces - 0x01 -> 18 veces - 0x02 -> 15 veces - -Offset 0x02885 (10373): - Valores distintos (9): 0x00, 0x01, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 120 veces - 0x00 -> 74 veces - 0x06 -> 14 veces - 0x04 -> 10 veces - 0x03 -> 7 veces - -Offset 0x02886 (10374): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 60 veces - 0x02 -> 51 veces - 0x05 -> 40 veces - 0xFF -> 27 veces - 0x07 -> 18 veces - -Offset 0x02887 (10375): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x05 -> 83 veces - 0x08 -> 49 veces - 0xFF -> 44 veces - 0x01 -> 25 veces - 0x04 -> 10 veces - -Offset 0x02888 (10376): - Valores distintos (7): 0x00, 0x04, 0x24, 0xA4, 0xAC, 0xEC, 0xEE - Clasificación: small_state - Más frecuentes: - 0xEE -> 116 veces - 0xEC -> 38 veces - 0xA4 -> 32 veces - 0xAC -> 28 veces - 0x24 -> 13 veces - -Offset 0x02889 (10377): - Valores distintos (7): 0x00, 0x08, 0x0C, 0x0E, 0x4E, 0xCE, 0xCF - Clasificación: small_state - Más frecuentes: - 0xCF -> 157 veces - 0x4E -> 40 veces - 0xCE -> 25 veces - 0x00 -> 5 veces - 0x0C -> 3 veces - -Offset 0x0288A (10378): - Valores distintos (8): 0x00, 0x80, 0xA0, 0xA2, 0xAA, 0xAE, 0xBE, 0xBF - Clasificación: small_state - Más frecuentes: - 0xBF -> 121 veces - 0xBE -> 70 veces - 0xAE -> 22 veces - 0x80 -> 10 veces - 0x00 -> 5 veces - -Offset 0x0288B (10379): - Valores distintos (3): 0x66, 0x67, 0xE7 - Clasificación: small_state - Más frecuentes: - 0xE7 -> 192 veces - 0x67 -> 37 veces - 0x66 -> 5 veces - -Offset 0x0288C (10380): - Valores distintos (7): 0x00, 0x20, 0xE0, 0xE6, 0xEE, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE6 -> 114 veces - 0xEE -> 33 veces - 0xFF -> 29 veces - 0xE0 -> 27 veces - 0x00 -> 15 veces - -Offset 0x0288D (10381): - Valores distintos (7): 0x00, 0x80, 0x81, 0x83, 0x93, 0xB3, 0xF3 - Clasificación: small_state - Más frecuentes: - 0x93 -> 117 veces - 0xB3 -> 46 veces - 0xF3 -> 29 veces - 0x83 -> 22 veces - 0x00 -> 10 veces - -Offset 0x0288E (10382): - Valores distintos (8): 0x00, 0x04, 0x0C, 0x0D, 0x2D, 0x3D, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2D -> 83 veces - 0xFF -> 77 veces - 0x3F -> 58 veces - 0x04 -> 7 veces - 0x00 -> 5 veces - -Offset 0x0288F (10383): - Valores distintos (8): 0x00, 0x60, 0x61, 0x63, 0xE3, 0xF3, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF7 -> 96 veces - 0xE3 -> 33 veces - 0x63 -> 28 veces - 0x60 -> 27 veces - 0xFF -> 20 veces - -Offset 0x02890 (10384): - Valores distintos (5): 0x00, 0x02, 0x82, 0x92, 0xF2 - Clasificación: small_state - Más frecuentes: - 0x92 -> 95 veces - 0x00 -> 52 veces - 0xF2 -> 44 veces - 0x82 -> 24 veces - 0x02 -> 19 veces - -Offset 0x02891 (10385): - Valores distintos (2): 0x00, 0x78 - Clasificación: small_state - Más frecuentes: - 0x78 -> 164 veces - 0x00 -> 70 veces - -Offset 0x02892 (10386): - Valores distintos (5): 0x00, 0x02, 0x07, 0xE7, 0xEF - Clasificación: small_state - Más frecuentes: - 0xE7 -> 143 veces - 0x07 -> 29 veces - 0x00 -> 22 veces - 0x02 -> 20 veces - 0xEF -> 20 veces - -Offset 0x02893 (10387): - Valores distintos (6): 0x00, 0x10, 0x12, 0x16, 0x5E, 0x7E - Clasificación: small_state - Más frecuentes: - 0x7E -> 141 veces - 0x00 -> 46 veces - 0x10 -> 36 veces - 0x12 -> 5 veces - 0x16 -> 3 veces - -Offset 0x02894 (10388): - Valores distintos (6): 0x00, 0x02, 0x1E, 0xBE, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 116 veces - 0x00 -> 91 veces - 0xFE -> 20 veces - 0xBE -> 3 veces - 0x02 -> 2 veces - -Offset 0x02895 (10389): - Valores distintos (8): 0x00, 0x01, 0x81, 0xC1, 0xC9, 0xE9, 0xED, 0xFD - Clasificación: small_state - Más frecuentes: - 0xED -> 73 veces - 0xFD -> 57 veces - 0x00 -> 52 veces - 0x01 -> 43 veces - 0xE9 -> 5 veces - -Offset 0x02896 (10390): - Valores distintos (8): 0x00, 0x04, 0x14, 0x1C, 0x7C, 0xFC, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 67 veces - 0xFF -> 57 veces - 0x00 -> 46 veces - 0xFD -> 20 veces - 0xFC -> 19 veces - -Offset 0x02897 (10391): - Valores distintos (5): 0x00, 0x80, 0xA0, 0xA8, 0xA9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0xA9 -> 43 veces - 0xA0 -> 30 veces - 0x80 -> 1 veces - 0xA8 -> 1 veces - -Offset 0x02898 (10392): - Valores distintos (7): 0x00, 0x12, 0x32, 0x36, 0x37, 0xB7, 0xF7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 138 veces - 0xB7 -> 27 veces - 0x36 -> 22 veces - 0xF7 -> 20 veces - 0x12 -> 15 veces - -Offset 0x02899 (10393): - Valores distintos (7): 0x00, 0x20, 0x30, 0x38, 0x7A, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 157 veces - 0x7F -> 24 veces - 0x30 -> 19 veces - 0xFF -> 19 veces - 0x38 -> 11 veces - -Offset 0x0289A (10394): - Valores distintos (7): 0x00, 0x48, 0x49, 0x59, 0x5D, 0x5F, 0xDF - Clasificación: small_state - Más frecuentes: - 0x00 -> 157 veces - 0x5F -> 28 veces - 0xDF -> 16 veces - 0x49 -> 14 veces - 0x5D -> 13 veces - -Offset 0x0289B (10395): - Valores distintos (7): 0x00, 0x40, 0x49, 0x6D, 0x6F, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 215 veces - 0xFF -> 14 veces - 0x40 -> 1 veces - 0x49 -> 1 veces - 0x6D -> 1 veces - -Offset 0x0289C (10396): - Valores distintos (7): 0x00, 0x10, 0x30, 0x38, 0x78, 0xF8, 0xFF - Clasificación: small_state - Más frecuentes: - 0x38 -> 94 veces - 0x00 -> 52 veces - 0x10 -> 38 veces - 0xFF -> 19 veces - 0x78 -> 14 veces - -Offset 0x0289D (10397): - Valores distintos (7): 0x00, 0x08, 0xC8, 0xE8, 0xEC, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 107 veces - 0x00 -> 52 veces - 0xC8 -> 28 veces - 0xE8 -> 18 veces - 0xEF -> 10 veces - -Offset 0x0289E (10398): - Valores distintos (4): 0x00, 0x03, 0x0F, 0x2F - Clasificación: small_state - Más frecuentes: - 0x00 -> 113 veces - 0x03 -> 74 veces - 0x0F -> 37 veces - 0x2F -> 10 veces - -Offset 0x028A8 (10408): - Valores distintos (3): 0x00, 0x08, 0x48 - Clasificación: small_state - Más frecuentes: - 0x08 -> 123 veces - 0x00 -> 71 veces - 0x48 -> 40 veces - -Offset 0x028A9 (10409): - Valores distintos (4): 0x00, 0x04, 0x84, 0xC4 - Clasificación: small_state - Más frecuentes: - 0x84 -> 125 veces - 0x00 -> 71 veces - 0x04 -> 34 veces - 0xC4 -> 4 veces - -Offset 0x028AA (10410): - Valores distintos (5): 0x00, 0x10, 0x50, 0x58, 0x59 - Clasificación: small_state - Más frecuentes: - 0x10 -> 107 veces - 0x00 -> 71 veces - 0x50 -> 31 veces - 0x59 -> 19 veces - 0x58 -> 6 veces - -Offset 0x028AB (10411): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x04 -> 129 veces - 0x00 -> 105 veces - -Offset 0x028AC (10412): - Valores distintos (4): 0x00, 0x80, 0x90, 0xD0 - Clasificación: small_state - Más frecuentes: - 0x90 -> 155 veces - 0x00 -> 33 veces - 0x80 -> 23 veces - 0xD0 -> 23 veces - -Offset 0x028AD (10413): - Valores distintos (5): 0x00, 0x04, 0x05, 0x0D, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 182 veces - 0x0F -> 23 veces - 0x05 -> 15 veces - 0x04 -> 12 veces - 0x0D -> 2 veces - -Offset 0x028AF (10415): - Valores distintos (5): 0x00, 0x04, 0x44, 0xC4, 0xE4 - Clasificación: small_state - Más frecuentes: - 0x04 -> 150 veces - 0x00 -> 55 veces - 0xC4 -> 18 veces - 0x44 -> 6 veces - 0xE4 -> 5 veces - -Offset 0x028B0 (10416): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x20 -> 221 veces - 0x00 -> 13 veces - -Offset 0x028B6 (10422): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x80 -> 214 veces - 0x00 -> 20 veces - -Offset 0x028B9 (10425): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x10 -> 25 veces - -Offset 0x028BB (10427): - Valores distintos (5): 0x00, 0x02, 0x26, 0x66, 0x76 - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x02 -> 94 veces - 0x76 -> 25 veces - 0x26 -> 6 veces - 0x66 -> 4 veces - -Offset 0x028BC (10428): - Valores distintos (5): 0x00, 0x30, 0x70, 0x78, 0x7E - Clasificación: small_state - Más frecuentes: - 0x00 -> 71 veces - 0x30 -> 71 veces - 0x70 -> 53 veces - 0x78 -> 34 veces - 0x7E -> 5 veces - -Offset 0x028BD (10429): - Valores distintos (7): 0x00, 0x04, 0x24, 0x26, 0x36, 0x3E, 0x3F - Clasificación: small_state - Más frecuentes: - 0x04 -> 115 veces - 0x26 -> 46 veces - 0x00 -> 27 veces - 0x3E -> 21 veces - 0x36 -> 14 veces - -Offset 0x028BE (10430): - Valores distintos (2): 0x00, 0x08 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x08 -> 107 veces - -Offset 0x028BF (10431): - Valores distintos (3): 0x00, 0x02, 0x12 - Clasificación: small_state - Más frecuentes: - 0x02 -> 110 veces - 0x12 -> 65 veces - 0x00 -> 59 veces - -Offset 0x028C0 (10432): - Valores distintos (4): 0x00, 0x08, 0x48, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0x58 -> 39 veces - 0x08 -> 23 veces - 0x48 -> 13 veces - -Offset 0x028C1 (10433): - Valores distintos (5): 0x00, 0x80, 0x82, 0x8A, 0xCA - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x80 -> 56 veces - 0xCA -> 35 veces - 0x82 -> 6 veces - 0x8A -> 2 veces - -Offset 0x028C3 (10435): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 142 veces - 0x01 -> 92 veces - -Offset 0x028E8 (10472): - Valores distintos (62): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x30, 0x31, 0x32, 0x33, 0x35, 0x36, 0x37, 0x38, 0x3B, 0x3D, 0x3F, 0x41, 0x43, 0x44, 0x45, 0x46, 0x47 - Clasificación: bitfield_like - Más frecuentes: - 0x06 -> 14 veces - 0x19 -> 9 veces - 0x05 -> 8 veces - 0x0C -> 8 veces - 0x29 -> 8 veces - -Offset 0x028E9 (10473): - Valores distintos (56): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A - Clasificación: bitfield_like - Más frecuentes: - 0x08 -> 13 veces - 0x06 -> 12 veces - 0x1A -> 11 veces - 0x02 -> 8 veces - 0x38 -> 7 veces - -Offset 0x028EA (10474): - Valores distintos (55): 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2F, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B - Clasificación: bitfield_like - Más frecuentes: - 0x35 -> 12 veces - 0x18 -> 10 veces - 0x03 -> 9 veces - 0x10 -> 9 veces - 0x27 -> 9 veces - -Offset 0x028EB (10475): - Valores distintos (30): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D - Clasificación: bitfield_like - Más frecuentes: - 0x18 -> 16 veces - 0x0C -> 16 veces - 0x1C -> 15 veces - 0x03 -> 14 veces - 0x1D -> 13 veces - -Offset 0x028EC (10476): - Valores distintos (2): 0x01, 0x21 - Clasificación: small_state - Más frecuentes: - 0x21 -> 229 veces - 0x01 -> 5 veces - -Offset 0x028ED (10477): - Valores distintos (4): 0x00, 0x22, 0x7E, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 139 veces - 0x7E -> 83 veces - 0x00 -> 10 veces - 0x22 -> 2 veces - -Offset 0x028EE (10478): - Valores distintos (5): 0x00, 0x08, 0x18, 0xF8, 0xFB - Clasificación: small_state - Más frecuentes: - 0xFB -> 139 veces - 0xF8 -> 53 veces - 0x18 -> 21 veces - 0x00 -> 20 veces - 0x08 -> 1 veces - -Offset 0x028EF (10479): - Valores distintos (4): 0x00, 0x80, 0x8D, 0x8F - Clasificación: small_state - Más frecuentes: - 0x8F -> 98 veces - 0x8D -> 94 veces - 0x80 -> 22 veces - 0x00 -> 20 veces - -Offset 0x028F0 (10480): - Valores distintos (4): 0x00, 0x01, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 182 veces - 0x01 -> 26 veces - 0x00 -> 20 veces - 0x7F -> 6 veces - -Offset 0x028F1 (10481): - Valores distintos (4): 0x00, 0x07, 0x77, 0xF7 - Clasificación: small_state - Más frecuentes: - 0x77 -> 115 veces - 0x00 -> 52 veces - 0x07 -> 38 veces - 0xF7 -> 29 veces - -Offset 0x028F2 (10482): - Valores distintos (4): 0x00, 0x3C, 0xFC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 114 veces - 0x00 -> 90 veces - 0xFC -> 27 veces - 0x3C -> 3 veces - -Offset 0x028F3 (10483): - Valores distintos (4): 0x00, 0x40, 0x47, 0xF7 - Clasificación: small_state - Más frecuentes: - 0xF7 -> 139 veces - 0x40 -> 47 veces - 0x00 -> 46 veces - 0x47 -> 2 veces - -Offset 0x028F4 (10484): - Valores distintos (4): 0x00, 0x08, 0x0F, 0x8F - Clasificación: small_state - Más frecuentes: - 0x8F -> 81 veces - 0x0F -> 58 veces - 0x08 -> 53 veces - 0x00 -> 42 veces - -Offset 0x028F5 (10485): - Valores distintos (7): 0x00, 0x03, 0x0F, 0x1F, 0x5F, 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 96 veces - 0xFF -> 85 veces - 0xDF -> 36 veces - 0x5F -> 13 veces - 0x03 -> 2 veces - -Offset 0x028F6 (10486): - Valores distintos (5): 0x00, 0x04, 0x0F, 0x5F, 0x7F - Clasificación: small_state - Más frecuentes: - 0x7F -> 107 veces - 0x00 -> 103 veces - 0x04 -> 10 veces - 0x5F -> 9 veces - 0x0F -> 5 veces - -Offset 0x028F7 (10487): - Valores distintos (3): 0x00, 0x60, 0x68 - Clasificación: small_state - Más frecuentes: - 0x68 -> 104 veces - 0x00 -> 74 veces - 0x60 -> 56 veces - -Offset 0x028F8 (10488): - Valores distintos (8): 0x00, 0x01, 0x03, 0x23, 0x63, 0xE3, 0xEB, 0xFB - Clasificación: small_state - Más frecuentes: - 0x01 -> 58 veces - 0xEB -> 55 veces - 0x00 -> 46 veces - 0x03 -> 34 veces - 0xFB -> 20 veces - -Offset 0x028F9 (10489): - Valores distintos (4): 0x00, 0x38, 0x39, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0xFD -> 75 veces - 0x38 -> 6 veces - 0x39 -> 4 veces - -Offset 0x028FA (10490): - Valores distintos (4): 0x00, 0x1F, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 160 veces - 0xFF -> 56 veces - 0x1F -> 17 veces - 0x3F -> 1 veces - -Offset 0x028FB (10491): - Valores distintos (4): 0x00, 0x04, 0x1F, 0x9F - Clasificación: small_state - Más frecuentes: - 0x00 -> 179 veces - 0x9F -> 44 veces - 0x1F -> 10 veces - 0x04 -> 1 veces - -Offset 0x028FC (10492): - Valores distintos (4): 0x00, 0x01, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 190 veces - 0xFF -> 20 veces - 0x3F -> 13 veces - 0x01 -> 11 veces - -Offset 0x028FD (10493): - Valores distintos (5): 0x00, 0x0B, 0x1B, 0x9B, 0xBB - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0xBB -> 16 veces - 0x0B -> 2 veces - 0x1B -> 1 veces - 0x9B -> 1 veces - -Offset 0x028FE (10494): - Valores distintos (3): 0x00, 0x08, 0x09 - Clasificación: small_state - Más frecuentes: - 0x09 -> 118 veces - 0x00 -> 95 veces - 0x08 -> 21 veces - -Offset 0x028FF (10495): - Valores distintos (6): 0x00, 0x20, 0x2C, 0x2E, 0x3E, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x20 -> 62 veces - 0xFE -> 44 veces - 0x2C -> 22 veces - 0x3E -> 10 veces - -Offset 0x02900 (10496): - Valores distintos (5): 0x00, 0x20, 0xA0, 0xA6, 0xA7 - Clasificación: small_state - Más frecuentes: - 0xA0 -> 167 veces - 0xA7 -> 33 veces - 0x00 -> 15 veces - 0xA6 -> 14 veces - 0x20 -> 5 veces - -Offset 0x02901 (10497): - Valores distintos (4): 0x00, 0x10, 0x30, 0x34 - Clasificación: small_state - Más frecuentes: - 0x00 -> 96 veces - 0x34 -> 74 veces - 0x10 -> 57 veces - 0x30 -> 7 veces - -Offset 0x0290C (10508): - Valores distintos (2): 0x00, 0x1B - Clasificación: small_state - Más frecuentes: - 0x1B -> 158 veces - 0x00 -> 76 veces - -Offset 0x0290D (10509): - Valores distintos (3): 0x00, 0x26, 0x27 - Clasificación: small_state - Más frecuentes: - 0x27 -> 158 veces - 0x26 -> 64 veces - 0x00 -> 12 veces - -Offset 0x02910 (10512): - Valores distintos (2): 0x00, 0x3B - Clasificación: small_state - Más frecuentes: - 0x3B -> 158 veces - 0x00 -> 76 veces - -Offset 0x02911 (10513): - Valores distintos (2): 0x00, 0x28 - Clasificación: small_state - Más frecuentes: - 0x28 -> 136 veces - 0x00 -> 98 veces - -Offset 0x02913 (10515): - Valores distintos (2): 0x00, 0x42 - Clasificación: small_state - Más frecuentes: - 0x00 -> 196 veces - 0x42 -> 38 veces - -Offset 0x02916 (10518): - Valores distintos (2): 0x00, 0x1F - Clasificación: small_state - Más frecuentes: - 0x1F -> 155 veces - 0x00 -> 79 veces - -Offset 0x02917 (10519): - Valores distintos (3): 0x00, 0x11, 0x12 - Clasificación: small_state - Más frecuentes: - 0x12 -> 155 veces - 0x00 -> 75 veces - 0x11 -> 4 veces - -Offset 0x02918 (10520): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x10 -> 159 veces - 0x00 -> 75 veces - -Offset 0x02919 (10521): - Valores distintos (2): 0x00, 0x18 - Clasificación: small_state - Más frecuentes: - 0x18 -> 139 veces - 0x00 -> 95 veces - -Offset 0x0291A (10522): - Valores distintos (3): 0x00, 0x23, 0x38 - Clasificación: small_state - Más frecuentes: - 0x23 -> 116 veces - 0x00 -> 79 veces - 0x38 -> 39 veces - -Offset 0x0291B (10523): - Valores distintos (3): 0x00, 0x34, 0x37 - Clasificación: small_state - Más frecuentes: - 0x37 -> 139 veces - 0x00 -> 75 veces - 0x34 -> 20 veces - -Offset 0x0291C (10524): - Valores distintos (3): 0x00, 0x26, 0x44 - Clasificación: small_state - Más frecuentes: - 0x26 -> 119 veces - 0x00 -> 76 veces - 0x44 -> 39 veces - -Offset 0x0291D (10525): - Valores distintos (2): 0x00, 0x54 - Clasificación: small_state - Más frecuentes: - 0x00 -> 195 veces - 0x54 -> 39 veces - -Offset 0x0291E (10526): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x00 -> 195 veces - 0x4B -> 39 veces - -Offset 0x02921 (10529): - Valores distintos (3): 0x00, 0x2B, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x41 -> 88 veces - 0x2B -> 4 veces - -Offset 0x0292C (10540): - Valores distintos (5): 0x00, 0x60, 0x70, 0x7C, 0x7E - Clasificación: small_state - Más frecuentes: - 0x7C -> 183 veces - 0x7E -> 31 veces - 0x70 -> 10 veces - 0x00 -> 5 veces - 0x60 -> 5 veces - -Offset 0x0292D (10541): - Valores distintos (4): 0x00, 0x01, 0x81, 0x85 - Clasificación: small_state - Más frecuentes: - 0x85 -> 218 veces - 0x01 -> 8 veces - 0x00 -> 7 veces - 0x81 -> 1 veces - -Offset 0x0292E (10542): - Valores distintos (3): 0x00, 0x06, 0x0F - Clasificación: small_state - Más frecuentes: - 0x0F -> 218 veces - 0x00 -> 15 veces - 0x06 -> 1 veces - -Offset 0x0292F (10543): - Valores distintos (3): 0x00, 0xC0, 0xE0 - Clasificación: small_state - Más frecuentes: - 0xE0 -> 133 veces - 0x00 -> 76 veces - 0xC0 -> 25 veces - -Offset 0x02930 (10544): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 158 veces - 0x00 -> 76 veces - -Offset 0x02931 (10545): - Valores distintos (3): 0x00, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 136 veces - 0x00 -> 76 veces - 0x3F -> 22 veces - -Offset 0x02932 (10546): - Valores distintos (3): 0x00, 0xC0, 0xCC - Clasificación: small_state - Más frecuentes: - 0xCC -> 172 veces - 0x00 -> 50 veces - 0xC0 -> 12 veces - -Offset 0x02933 (10547): - Valores distintos (4): 0x00, 0x04, 0x07, 0x4F - Clasificación: small_state - Más frecuentes: - 0x4F -> 154 veces - 0x00 -> 42 veces - 0x07 -> 30 veces - 0x04 -> 8 veces - -Offset 0x02934 (10548): - Valores distintos (6): 0x00, 0x20, 0xE0, 0xE8, 0xEE, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 91 veces - 0xEE -> 48 veces - 0x00 -> 42 veces - 0x20 -> 28 veces - 0xE8 -> 23 veces - -Offset 0x02935 (10549): - Valores distintos (3): 0x00, 0x03, 0x3B - Clasificación: small_state - Más frecuentes: - 0x3B -> 121 veces - 0x00 -> 70 veces - 0x03 -> 43 veces - -Offset 0x02936 (10550): - Valores distintos (6): 0x00, 0x04, 0x14, 0x1C, 0x1E, 0xDE - Clasificación: small_state - Más frecuentes: - 0xDE -> 92 veces - 0x00 -> 60 veces - 0x1C -> 24 veces - 0x1E -> 22 veces - 0x04 -> 18 veces - -Offset 0x02937 (10551): - Valores distintos (5): 0x00, 0x01, 0x03, 0x13, 0xD7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 155 veces - 0xD7 -> 44 veces - 0x01 -> 18 veces - 0x03 -> 14 veces - 0x13 -> 3 veces - -Offset 0x02938 (10552): - Valores distintos (5): 0x00, 0x80, 0xC0, 0xCD, 0xFD - Clasificación: small_state - Más frecuentes: - 0x80 -> 90 veces - 0xC0 -> 58 veces - 0x00 -> 42 veces - 0xCD -> 24 veces - 0xFD -> 20 veces - -Offset 0x02939 (10553): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 169 veces - 0x01 -> 65 veces - -Offset 0x0294C (10572): - Valores distintos (17): 0x80, 0x81, 0x83, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92 - Clasificación: bitfield_like - Más frecuentes: - 0x8D -> 60 veces - 0x85 -> 37 veces - 0x81 -> 29 veces - 0x8A -> 21 veces - 0x91 -> 18 veces - -Offset 0x0294D (10573): - Valores distintos (2): 0x00, 0x60 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0x60 -> 5 veces - -Offset 0x0294E (10574): - Valores distintos (7): 0x00, 0x1C, 0x1D, 0x1E, 0x21, 0x25, 0x29 - Clasificación: small_state - Más frecuentes: - 0x1C -> 70 veces - 0x1D -> 52 veces - 0x1E -> 51 veces - 0x21 -> 44 veces - 0x00 -> 12 veces - -Offset 0x0294F (10575): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 222 veces - 0x00 -> 12 veces - -Offset 0x02950 (10576): - Valores distintos (6): 0x00, 0x2E, 0x2F, 0x30, 0x31, 0x32 - Clasificación: small_state - Más frecuentes: - 0x2F -> 67 veces - 0x2E -> 63 veces - 0x31 -> 38 veces - 0x32 -> 37 veces - 0x30 -> 17 veces - -Offset 0x02951 (10577): - Valores distintos (20): 0x07, 0x10, 0x21, 0x2D, 0x30, 0x38, 0x42, 0x4D, 0x61, 0x6B, 0x6F, 0x70, 0x71, 0x7C, 0x83, 0x8A, 0x8B, 0x8C, 0x95, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x4D -> 119 veces - 0x71 -> 30 veces - 0x8C -> 15 veces - 0x38 -> 9 veces - 0x83 -> 8 veces - -Offset 0x02954 (10580): - Valores distintos (125): 0x01, 0x03, 0x06, 0x08, 0x09, 0x0A, 0x0B, 0x0D, 0x0F, 0x10, 0x11, 0x12, 0x14, 0x16, 0x1A, 0x1B, 0x1D, 0x20, 0x23, 0x24, 0x26, 0x29, 0x2D, 0x2E, 0x31, 0x32, 0x33, 0x35, 0x37, 0x38, 0x39, 0x3B, 0x3C, 0x3E, 0x41, 0x43, 0x44, 0x45, 0x47, 0x48, 0x4E, 0x4F, 0x51, 0x52, 0x54, 0x55, 0x57, 0x58, 0x59, 0x5B, 0x62, 0x64, 0x66, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x74, 0x76, 0x77, 0x78, 0x7C, 0x7D, 0x82, 0x87, 0x89, 0x8D, 0x8E, 0x93, 0x94, 0x96, 0x9A, 0x9E, 0xA2, 0xA5, 0xA6, 0xA8, 0xAC, 0xAD, 0xAF, 0xB0, 0xB3, 0xB4, 0xB6, 0xB7, 0xB8, 0xBA, 0xBC, 0xBD, 0xC0, 0xC3, 0xC5, 0xC7, 0xC8, 0xC9, 0xCB, 0xCC, 0xCE, 0xCF, 0xD2, 0xD3, 0xD5, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xE0, 0xE3, 0xE4, 0xE5, 0xE8, 0xEB, 0xF0, 0xF3, 0xF4, 0xF5, 0xF7, 0xFC - Clasificación: bitfield_like - Más frecuentes: - 0x76 -> 11 veces - 0x78 -> 6 veces - 0x03 -> 5 veces - 0xAC -> 5 veces - 0xC8 -> 5 veces - -Offset 0x02955 (10581): - Valores distintos (8): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 46 veces - 0x01 -> 44 veces - 0x04 -> 38 veces - 0x02 -> 37 veces - 0x03 -> 34 veces - -Offset 0x02958 (10584): - Valores distintos (106): 0x00, 0x05, 0x09, 0x0A, 0x11, 0x13, 0x18, 0x1A, 0x1C, 0x1F, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x29, 0x2A, 0x2B, 0x2F, 0x30, 0x33, 0x34, 0x35, 0x39, 0x3A, 0x3D, 0x3E, 0x43, 0x44, 0x46, 0x48, 0x49, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x57, 0x5C, 0x5E, 0x5F, 0x60, 0x62, 0x64, 0x66, 0x67, 0x69, 0x75, 0x77, 0x79, 0x7B, 0x7C, 0x7F, 0x81, 0x86, 0x88, 0x89, 0x8C, 0x8E, 0x8F, 0x91, 0x96, 0x97, 0x98, 0x99, 0x9B, 0xA3, 0xA5, 0xA7, 0xAC, 0xB0, 0xB2, 0xB5, 0xB6, 0xB8, 0xBB, 0xBD, 0xBE, 0xBF, 0xC1, 0xC4, 0xC7, 0xC9, 0xCA, 0xCC, 0xCD, 0xD2, 0xD6, 0xDB, 0xDF, 0xE1, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xED, 0xF0, 0xF1, 0xF9, 0xFB, 0xFD, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xA3 -> 9 veces - 0x67 -> 9 veces - 0x00 -> 7 veces - 0xF1 -> 7 veces - 0x11 -> 7 veces - -Offset 0x02959 (10585): - Valores distintos (108): 0x00, 0x01, 0x03, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x14, 0x15, 0x1B, 0x1C, 0x1D, 0x1F, 0x21, 0x24, 0x27, 0x28, 0x29, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x35, 0x37, 0x38, 0x3B, 0x3C, 0x3F, 0x41, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4C, 0x4F, 0x56, 0x5B, 0x5C, 0x65, 0x68, 0x6B, 0x6E, 0x70, 0x73, 0x7A, 0x7C, 0x7F, 0x80, 0x83, 0x84, 0x89, 0x8D, 0x8F, 0x93, 0x96, 0x9B, 0x9D, 0xA2, 0xA7, 0xA9, 0xAB, 0xAC, 0xAE, 0xB1, 0xB3, 0xB4, 0xB6, 0xBE, 0xC7, 0xC8, 0xC9, 0xCE, 0xD2, 0xD4, 0xD7, 0xD9, 0xDA, 0xDB, 0xDC, 0xE2, 0xE3, 0xE7, 0xEA, 0xEB, 0xEC, 0xED, 0xF2, 0xF3, 0xF4, 0xF7, 0xFB, 0xFC, 0xFE, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x10 -> 9 veces - 0x4C -> 9 veces - 0x35 -> 8 veces - 0x00 -> 7 veces - 0x0B -> 7 veces - -Offset 0x0295A (10586): - Valores distintos (8): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x01 -> 46 veces - 0x06 -> 20 veces - 0x02 -> 17 veces - 0x03 -> 12 veces - -Offset 0x0295C (10588): - Valores distintos (32): 0x00, 0x02, 0x03, 0x04, 0x07, 0x0A, 0x0C, 0x0F, 0x13, 0x14, 0x16, 0x1A, 0x1B, 0x2B, 0x2C, 0x2E, 0x30, 0x31, 0x33, 0x34, 0x37, 0x38, 0x39, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x46, 0x47, 0x49 - Clasificación: bitfield_like - Más frecuentes: - 0x0C -> 22 veces - 0x49 -> 20 veces - 0x2E -> 15 veces - 0x3D -> 14 veces - 0x3F -> 14 veces - -Offset 0x02960 (10592): - Valores distintos (89): 0x01, 0x02, 0x04, 0x08, 0x09, 0x0B, 0x0F, 0x11, 0x12, 0x13, 0x15, 0x17, 0x18, 0x19, 0x1C, 0x1E, 0x1F, 0x21, 0x23, 0x24, 0x25, 0x2E, 0x36, 0x3B, 0x3D, 0x3E, 0x41, 0x43, 0x46, 0x47, 0x4E, 0x51, 0x53, 0x55, 0x56, 0x57, 0x5E, 0x63, 0x6F, 0x72, 0x7A, 0x7C, 0x7D, 0x7F, 0x80, 0x84, 0x85, 0x89, 0x8B, 0x92, 0x98, 0x99, 0x9A, 0xA4, 0xA6, 0xA7, 0xA8, 0xAC, 0xAE, 0xB1, 0xB3, 0xB6, 0xBA, 0xC0, 0xC1, 0xC3, 0xC4, 0xC6, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xD1, 0xD2, 0xD4, 0xD6, 0xDB, 0xE6, 0xEA, 0xF0, 0xF2, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE - Clasificación: bitfield_like - Más frecuentes: - 0xA8 -> 11 veces - 0xEA -> 11 veces - 0x57 -> 10 veces - 0x80 -> 9 veces - 0xF2 -> 9 veces - -Offset 0x02964 (10596): - Valores distintos (15): 0x00, 0x01, 0x02, 0x05, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x14, 0x15, 0x16 - Clasificación: bitfield_like - Más frecuentes: - 0x01 -> 63 veces - 0x0E -> 36 veces - 0x16 -> 35 veces - 0x0B -> 23 veces - 0x0A -> 20 veces - -Offset 0x02968 (10600): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0x80 -> 1 veces - -Offset 0x02969 (10601): - Valores distintos (3): 0x00, 0x80, 0x88 - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0x80 -> 8 veces - 0x88 -> 1 veces - -Offset 0x0296A (10602): - Valores distintos (40): 0x00, 0x05, 0x08, 0x12, 0x18, 0x1B, 0x1C, 0x1F, 0x20, 0x22, 0x23, 0x24, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3D, 0x3E, 0x40, 0x41, 0x42, 0x47 - Clasificación: bitfield_like - Más frecuentes: - 0x37 -> 25 veces - 0x2B -> 15 veces - 0x26 -> 13 veces - 0x31 -> 13 veces - 0x2C -> 13 veces - -Offset 0x0296B (10603): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0x15 -> 1 veces - -Offset 0x0296D (10605): - Valores distintos (2): 0x00, 0xAD - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0xAD -> 1 veces - -Offset 0x0296E (10606): - Valores distintos (40): 0x00, 0x06, 0x13, 0x14, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D - Clasificación: bitfield_like - Más frecuentes: - 0x25 -> 17 veces - 0x1E -> 11 veces - 0x3B -> 11 veces - 0x06 -> 11 veces - 0x2A -> 10 veces - -Offset 0x0296F (10607): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0x10 -> 1 veces - -Offset 0x02970 (10608): - Valores distintos (12): 0x00, 0x10, 0x21, 0x2D, 0x41, 0x57, 0x58, 0x62, 0x73, 0x97, 0x98, 0xBD - Clasificación: bitfield_like - Más frecuentes: - 0x57 -> 53 veces - 0x2D -> 39 veces - 0x41 -> 36 veces - 0x97 -> 34 veces - 0x10 -> 20 veces - -Offset 0x02972 (10610): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 154 veces - 0x00 -> 80 veces - -Offset 0x02973 (10611): - Valores distintos (5): 0x00, 0x02, 0x03, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 109 veces - 0x03 -> 71 veces - 0x05 -> 24 veces - 0x06 -> 23 veces - 0x02 -> 7 veces - -Offset 0x02974 (10612): - Valores distintos (3): 0x00, 0x04, 0x5B - Clasificación: small_state - Más frecuentes: - 0x04 -> 182 veces - 0x5B -> 47 veces - 0x00 -> 5 veces - -Offset 0x02975 (10613): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 229 veces - 0x00 -> 5 veces - -Offset 0x02976 (10614): - Valores distintos (2): 0x00, 0x29 - Clasificación: small_state - Más frecuentes: - 0x29 -> 229 veces - 0x00 -> 5 veces - -Offset 0x02977 (10615): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 229 veces - 0x00 -> 5 veces - -Offset 0x02978 (10616): - Valores distintos (2): 0x00, 0x0D - Clasificación: small_state - Más frecuentes: - 0x0D -> 227 veces - 0x00 -> 7 veces - -Offset 0x02979 (10617): - Valores distintos (4): 0x00, 0x0A, 0x22, 0x27 - Clasificación: small_state - Más frecuentes: - 0x0A -> 192 veces - 0x27 -> 22 veces - 0x00 -> 10 veces - 0x22 -> 10 veces - -Offset 0x0297A (10618): - Valores distintos (4): 0x00, 0x06, 0x0A, 0x27 - Clasificación: small_state - Más frecuentes: - 0x06 -> 192 veces - 0x0A -> 22 veces - 0x00 -> 10 veces - 0x27 -> 10 veces - -Offset 0x0297B (10619): - Valores distintos (4): 0x00, 0x06, 0x0A, 0x39 - Clasificación: small_state - Más frecuentes: - 0x39 -> 192 veces - 0x06 -> 22 veces - 0x00 -> 10 veces - 0x0A -> 10 veces - -Offset 0x0297C (10620): - Valores distintos (5): 0x00, 0x06, 0x1A, 0x27, 0x39 - Clasificación: small_state - Más frecuentes: - 0x27 -> 114 veces - 0x1A -> 78 veces - 0x39 -> 22 veces - 0x00 -> 12 veces - 0x06 -> 8 veces - -Offset 0x0297D (10621): - Valores distintos (6): 0x00, 0x05, 0x08, 0x1A, 0x27, 0x39 - Clasificación: small_state - Más frecuentes: - 0x08 -> 114 veces - 0x27 -> 49 veces - 0x05 -> 28 veces - 0x1A -> 22 veces - 0x00 -> 13 veces - -Offset 0x0297E (10622): - Valores distintos (6): 0x00, 0x05, 0x08, 0x0B, 0x0F, 0x18 - Clasificación: small_state - Más frecuentes: - 0x0F -> 114 veces - 0x08 -> 46 veces - 0x00 -> 35 veces - 0x05 -> 22 veces - 0x0B -> 10 veces - -Offset 0x0297F (10623): - Valores distintos (6): 0x00, 0x0B, 0x0F, 0x15, 0x22, 0x43 - Clasificación: small_state - Más frecuentes: - 0x43 -> 114 veces - 0x0F -> 68 veces - 0x0B -> 20 veces - 0x00 -> 17 veces - 0x22 -> 10 veces - -Offset 0x02980 (10624): - Valores distintos (7): 0x00, 0x0B, 0x18, 0x1A, 0x22, 0x43, 0x44 - Clasificación: small_state - Más frecuentes: - 0x44 -> 114 veces - 0x43 -> 40 veces - 0x0B -> 28 veces - 0x22 -> 22 veces - 0x00 -> 15 veces - -Offset 0x02981 (10625): - Valores distintos (7): 0x00, 0x05, 0x15, 0x18, 0x22, 0x3C, 0x44 - Clasificación: small_state - Más frecuentes: - 0x3C -> 114 veces - 0x44 -> 40 veces - 0x22 -> 28 veces - 0x18 -> 22 veces - 0x00 -> 16 veces - -Offset 0x02982 (10626): - Valores distintos (8): 0x00, 0x15, 0x16, 0x18, 0x38, 0x3C, 0x3D, 0x47 - Clasificación: small_state - Más frecuentes: - 0x38 -> 114 veces - 0x18 -> 28 veces - 0x15 -> 22 veces - 0x3C -> 21 veces - 0x00 -> 20 veces - -Offset 0x02983 (10627): - Valores distintos (7): 0x00, 0x02, 0x15, 0x16, 0x38, 0x3C, 0x58 - Clasificación: small_state - Más frecuentes: - 0x02 -> 114 veces - 0x15 -> 28 veces - 0x16 -> 22 veces - 0x38 -> 21 veces - 0x00 -> 20 veces - -Offset 0x02984 (10628): - Valores distintos (8): 0x00, 0x12, 0x16, 0x1F, 0x28, 0x38, 0x42, 0x4A - Clasificación: small_state - Más frecuentes: - 0x28 -> 74 veces - 0x00 -> 43 veces - 0x16 -> 28 veces - 0x42 -> 27 veces - 0x1F -> 21 veces - -Offset 0x02985 (10629): - Valores distintos (7): 0x00, 0x02, 0x14, 0x1F, 0x42, 0x46, 0x58 - Clasificación: small_state - Más frecuentes: - 0x42 -> 87 veces - 0x00 -> 42 veces - 0x58 -> 28 veces - 0x46 -> 27 veces - 0x02 -> 21 veces - -Offset 0x02986 (10630): - Valores distintos (7): 0x00, 0x02, 0x08, 0x12, 0x28, 0x45, 0x46 - Clasificación: small_state - Más frecuentes: - 0x46 -> 87 veces - 0x00 -> 42 veces - 0x12 -> 28 veces - 0x45 -> 27 veces - 0x28 -> 21 veces - -Offset 0x02987 (10631): - Valores distintos (7): 0x00, 0x05, 0x0F, 0x14, 0x19, 0x28, 0x45 - Clasificación: small_state - Más frecuentes: - 0x45 -> 87 veces - 0x00 -> 46 veces - 0x14 -> 28 veces - 0x05 -> 27 veces - 0x19 -> 21 veces - -Offset 0x02988 (10632): - Valores distintos (6): 0x00, 0x05, 0x07, 0x19, 0x21, 0x42 - Clasificación: small_state - Más frecuentes: - 0x05 -> 87 veces - 0x00 -> 46 veces - 0x21 -> 34 veces - 0x07 -> 27 veces - 0x42 -> 21 veces - -Offset 0x02989 (10633): - Valores distintos (6): 0x00, 0x07, 0x42, 0x43, 0x46, 0x56 - Clasificación: small_state - Más frecuentes: - 0x07 -> 87 veces - 0x00 -> 75 veces - 0x56 -> 27 veces - 0x46 -> 21 veces - 0x42 -> 19 veces - -Offset 0x0298A (10634): - Valores distintos (6): 0x00, 0x09, 0x1D, 0x44, 0x46, 0x56 - Clasificación: small_state - Más frecuentes: - 0x56 -> 87 veces - 0x00 -> 75 veces - 0x09 -> 27 veces - 0x1D -> 21 veces - 0x46 -> 19 veces - -Offset 0x0298B (10635): - Valores distintos (7): 0x00, 0x0B, 0x1D, 0x23, 0x3D, 0x47, 0x57 - Clasificación: small_state - Más frecuentes: - 0x3D -> 87 veces - 0x00 -> 75 veces - 0x23 -> 27 veces - 0x57 -> 21 veces - 0x0B -> 13 veces - -Offset 0x0298C (10636): - Valores distintos (7): 0x00, 0x0B, 0x1A, 0x1C, 0x22, 0x48, 0x57 - Clasificación: small_state - Más frecuentes: - 0x0B -> 87 veces - 0x00 -> 76 veces - 0x1A -> 27 veces - 0x1C -> 21 veces - 0x22 -> 13 veces - -Offset 0x0298D (10637): - Valores distintos (6): 0x00, 0x18, 0x1C, 0x1F, 0x3C, 0x45 - Clasificación: small_state - Más frecuentes: - 0x18 -> 100 veces - 0x00 -> 76 veces - 0x1F -> 27 veces - 0x45 -> 21 veces - 0x1C -> 6 veces - -Offset 0x0298E (10638): - Valores distintos (6): 0x00, 0x05, 0x0B, 0x15, 0x19, 0x38 - Clasificación: small_state - Más frecuentes: - 0x15 -> 100 veces - 0x00 -> 76 veces - 0x19 -> 27 veces - 0x05 -> 21 veces - 0x0B -> 6 veces - -Offset 0x0298F (10639): - Valores distintos (6): 0x00, 0x07, 0x0E, 0x16, 0x1D, 0x22 - Clasificación: small_state - Más frecuentes: - 0x16 -> 100 veces - 0x00 -> 76 veces - 0x1D -> 27 veces - 0x07 -> 21 veces - 0x22 -> 6 veces - -Offset 0x02990 (10640): - Valores distintos (7): 0x00, 0x12, 0x18, 0x1F, 0x56, 0x57, 0x58 - Clasificación: small_state - Más frecuentes: - 0x12 -> 87 veces - 0x00 -> 76 veces - 0x57 -> 27 veces - 0x56 -> 21 veces - 0x58 -> 13 veces - -Offset 0x02991 (10641): - Valores distintos (7): 0x00, 0x02, 0x12, 0x14, 0x15, 0x1C, 0x3D - Clasificación: small_state - Más frecuentes: - 0x14 -> 87 veces - 0x00 -> 76 veces - 0x1C -> 27 veces - 0x3D -> 21 veces - 0x12 -> 13 veces - -Offset 0x02992 (10642): - Valores distintos (7): 0x00, 0x0B, 0x14, 0x16, 0x1E, 0x21, 0x26 - Clasificación: small_state - Más frecuentes: - 0x21 -> 87 veces - 0x00 -> 76 veces - 0x1E -> 27 veces - 0x0B -> 21 veces - 0x14 -> 13 veces - -Offset 0x02993 (10643): - Valores distintos (6): 0x00, 0x21, 0x22, 0x28, 0x48, 0x58 - Clasificación: small_state - Más frecuentes: - 0x48 -> 87 veces - 0x00 -> 76 veces - 0x28 -> 31 veces - 0x22 -> 21 veces - 0x21 -> 13 veces - -Offset 0x02994 (10644): - Valores distintos (7): 0x00, 0x0E, 0x12, 0x18, 0x19, 0x24, 0x48 - Clasificación: small_state - Más frecuentes: - 0x0E -> 87 veces - 0x00 -> 78 veces - 0x24 -> 27 veces - 0x18 -> 21 veces - 0x48 -> 13 veces - -Offset 0x02995 (10645): - Valores distintos (7): 0x00, 0x0E, 0x14, 0x15, 0x17, 0x1B, 0x42 - Clasificación: small_state - Más frecuentes: - 0x17 -> 87 veces - 0x00 -> 79 veces - 0x1B -> 27 veces - 0x15 -> 21 veces - 0x0E -> 13 veces - -Offset 0x02996 (10646): - Valores distintos (7): 0x00, 0x04, 0x16, 0x20, 0x21, 0x26, 0x46 - Clasificación: small_state - Más frecuentes: - 0x20 -> 87 veces - 0x00 -> 79 veces - 0x04 -> 27 veces - 0x16 -> 21 veces - 0x26 -> 13 veces - -Offset 0x02997 (10647): - Valores distintos (7): 0x00, 0x09, 0x1A, 0x1D, 0x48, 0x58, 0x5A - Clasificación: small_state - Más frecuentes: - 0x00 -> 90 veces - 0x09 -> 65 veces - 0x5A -> 27 veces - 0x1A -> 22 veces - 0x58 -> 21 veces - -Offset 0x02998 (10648): - Valores distintos (7): 0x00, 0x0E, 0x12, 0x1F, 0x23, 0x2A, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 90 veces - 0x23 -> 65 veces - 0x2A -> 27 veces - 0x1F -> 22 veces - 0x12 -> 21 veces - -Offset 0x02999 (10649): - Valores distintos (6): 0x00, 0x14, 0x19, 0x1A, 0x26, 0x4A - Clasificación: small_state - Más frecuentes: - 0x00 -> 93 veces - 0x1A -> 65 veces - 0x4A -> 27 veces - 0x19 -> 22 veces - 0x14 -> 21 veces - -Offset 0x0299A (10650): - Valores distintos (6): 0x00, 0x1D, 0x1F, 0x21, 0x3D, 0x45 - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x1F -> 65 veces - 0x3D -> 27 veces - 0x1D -> 22 veces - 0x21 -> 21 veces - -Offset 0x0299B (10651): - Valores distintos (6): 0x00, 0x05, 0x0B, 0x19, 0x48, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x19 -> 65 veces - 0x0B -> 27 veces - 0x57 -> 22 veces - 0x48 -> 21 veces - -Offset 0x0299C (10652): - Valores distintos (6): 0x00, 0x07, 0x0E, 0x18, 0x1C, 0x1D - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x1D -> 65 veces - 0x18 -> 27 veces - 0x1C -> 22 veces - 0x0E -> 21 veces - -Offset 0x0299D (10653): - Valores distintos (6): 0x00, 0x15, 0x17, 0x22, 0x26, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x57 -> 65 veces - 0x15 -> 27 veces - 0x22 -> 22 veces - 0x26 -> 21 veces - -Offset 0x0299E (10654): - Valores distintos (5): 0x00, 0x16, 0x17, 0x1C, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 99 veces - 0x1C -> 65 veces - 0x16 -> 27 veces - 0x58 -> 22 veces - 0x17 -> 21 veces - -Offset 0x0299F (10655): - Valores distintos (5): 0x00, 0x12, 0x20, 0x22, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 99 veces - 0x22 -> 65 veces - 0x12 -> 27 veces - 0x26 -> 22 veces - 0x20 -> 21 veces - -Offset 0x029A0 (10656): - Valores distintos (4): 0x00, 0x14, 0x32, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 103 veces - 0x58 -> 65 veces - 0x32 -> 39 veces - 0x14 -> 27 veces - -Offset 0x029A1 (10657): - Valores distintos (4): 0x00, 0x1E, 0x21, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 118 veces - 0x26 -> 65 veces - 0x21 -> 27 veces - 0x1E -> 24 veces - -Offset 0x029A2 (10658): - Valores distintos (4): 0x00, 0x32, 0x48, 0x59 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x32 -> 65 veces - 0x48 -> 27 veces - 0x59 -> 22 veces - -Offset 0x029A3 (10659): - Valores distintos (4): 0x00, 0x09, 0x0E, 0x1E - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x1E -> 65 veces - 0x0E -> 27 veces - 0x09 -> 15 veces - -Offset 0x029A4 (10660): - Valores distintos (4): 0x00, 0x17, 0x28, 0x59 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x59 -> 57 veces - 0x17 -> 27 veces - 0x28 -> 8 veces - -Offset 0x029A5 (10661): - Valores distintos (3): 0x00, 0x20, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x4D -> 65 veces - 0x20 -> 27 veces - -Offset 0x029A6 (10662): - Valores distintos (3): 0x00, 0x22, 0x24 - Clasificación: small_state - Más frecuentes: - 0x00 -> 143 veces - 0x24 -> 64 veces - 0x22 -> 27 veces - -Offset 0x029A7 (10663): - Valores distintos (3): 0x00, 0x1B, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 164 veces - 0x1B -> 43 veces - 0x58 -> 27 veces - -Offset 0x029A8 (10664): - Valores distintos (3): 0x00, 0x04, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0x26 -> 27 veces - 0x04 -> 20 veces - -Offset 0x029A9 (10665): - Valores distintos (3): 0x00, 0x32, 0x5A - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0x32 -> 27 veces - 0x5A -> 20 veces - -Offset 0x029AA (10666): - Valores distintos (4): 0x00, 0x2A, 0x49, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 203 veces - 0x4D -> 27 veces - 0x49 -> 2 veces - 0x2A -> 2 veces - -Offset 0x029AB (10667): - Valores distintos (3): 0x00, 0x37, 0x3F - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x37 -> 20 veces - 0x3F -> 1 veces - -Offset 0x029F4 (10740): - Valores distintos (11): 0x00, 0x01, 0x1C, 0x1D, 0x2A, 0x45, 0x46, 0x47, 0x49, 0x4E, 0x52 - Clasificación: bitfield_like - Más frecuentes: - 0x47 -> 53 veces - 0x52 -> 49 veces - 0x1C -> 30 veces - 0x4E -> 27 veces - 0x49 -> 22 veces - -Offset 0x029F5 (10741): - Valores distintos (7): 0x00, 0x02, 0x46, 0x47, 0x48, 0x49, 0x4F - Clasificación: small_state - Más frecuentes: - 0x49 -> 65 veces - 0x48 -> 53 veces - 0x02 -> 30 veces - 0x4F -> 27 veces - 0x46 -> 22 veces - -Offset 0x029F6 (10742): - Valores distintos (12): 0x00, 0x04, 0x06, 0x07, 0x08, 0x09, 0x14, 0x1D, 0x20, 0x46, 0x47, 0x48 - Clasificación: bitfield_like - Más frecuentes: - 0x46 -> 65 veces - 0x1D -> 29 veces - 0x14 -> 27 veces - 0x00 -> 24 veces - 0x47 -> 22 veces - -Offset 0x029F7 (10743): - Valores distintos (11): 0x00, 0x04, 0x06, 0x09, 0x20, 0x3A, 0x45, 0x47, 0x48, 0x49, 0x4C - Clasificación: bitfield_like - Más frecuentes: - 0x47 -> 65 veces - 0x00 -> 48 veces - 0x4C -> 27 veces - 0x45 -> 22 veces - 0x48 -> 22 veces - -Offset 0x029F8 (10744): - Valores distintos (9): 0x00, 0x02, 0x06, 0x07, 0x12, 0x1F, 0x20, 0x39, 0x48 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 71 veces - 0x48 -> 65 veces - 0x07 -> 43 veces - 0x12 -> 27 veces - 0x20 -> 9 veces - -Offset 0x029F9 (10745): - Valores distintos (10): 0x00, 0x03, 0x07, 0x20, 0x21, 0x29, 0x33, 0x38, 0x39, 0x3A - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 74 veces - 0x07 -> 65 veces - 0x33 -> 27 veces - 0x21 -> 22 veces - 0x3A -> 18 veces - -Offset 0x029FA (10746): - Valores distintos (8): 0x00, 0x03, 0x04, 0x06, 0x21, 0x29, 0x39, 0x40 - Clasificación: small_state - Más frecuentes: - 0x00 -> 72 veces - 0x21 -> 65 veces - 0x06 -> 43 veces - 0x40 -> 27 veces - 0x29 -> 9 veces - -Offset 0x029FB (10747): - Valores distintos (8): 0x00, 0x02, 0x04, 0x06, 0x11, 0x1F, 0x20, 0x29 - Clasificación: small_state - Más frecuentes: - 0x00 -> 72 veces - 0x06 -> 65 veces - 0x20 -> 43 veces - 0x11 -> 27 veces - 0x04 -> 9 veces - -Offset 0x029FC (10748): - Valores distintos (8): 0x00, 0x04, 0x1C, 0x1F, 0x20, 0x38, 0x39, 0x4A - Clasificación: small_state - Más frecuentes: - 0x00 -> 72 veces - 0x20 -> 65 veces - 0x39 -> 43 veces - 0x4A -> 27 veces - 0x1F -> 9 veces - -Offset 0x029FD (10749): - Valores distintos (8): 0x00, 0x03, 0x08, 0x1F, 0x29, 0x38, 0x39, 0x49 - Clasificación: small_state - Más frecuentes: - 0x00 -> 76 veces - 0x39 -> 65 veces - 0x29 -> 43 veces - 0x49 -> 27 veces - 0x38 -> 9 veces - -Offset 0x029FE (10750): - Valores distintos (7): 0x00, 0x02, 0x03, 0x04, 0x29, 0x38, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 80 veces - 0x29 -> 65 veces - 0x04 -> 43 veces - 0x4D -> 27 veces - 0x03 -> 9 veces - -Offset 0x029FF (10751): - Valores distintos (7): 0x00, 0x02, 0x03, 0x04, 0x10, 0x1C, 0x1F - Clasificación: small_state - Más frecuentes: - 0x00 -> 80 veces - 0x04 -> 65 veces - 0x1F -> 43 veces - 0x10 -> 27 veces - 0x02 -> 9 veces - -Offset 0x02A00 (10752): - Valores distintos (6): 0x00, 0x02, 0x1C, 0x1F, 0x26, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 84 veces - 0x1F -> 65 veces - 0x38 -> 43 veces - 0x26 -> 27 veces - 0x1C -> 9 veces - -Offset 0x02A01 (10753): - Valores distintos (5): 0x00, 0x03, 0x0E, 0x1C, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 93 veces - 0x38 -> 65 veces - 0x03 -> 43 veces - 0x0E -> 27 veces - 0x1C -> 6 veces - -Offset 0x02A02 (10754): - Valores distintos (5): 0x00, 0x02, 0x03, 0x42, 0x46 - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x03 -> 65 veces - 0x02 -> 43 veces - 0x42 -> 27 veces - 0x46 -> 4 veces - -Offset 0x02A03 (10755): - Valores distintos (5): 0x00, 0x02, 0x09, 0x0C, 0x1C - Clasificación: small_state - Más frecuentes: - 0x00 -> 96 veces - 0x09 -> 60 veces - 0x1C -> 43 veces - 0x0C -> 27 veces - 0x02 -> 8 veces - -Offset 0x02A04 (10756): - Valores distintos (6): 0x00, 0x1C, 0x21, 0x2A, 0x46, 0x52 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x1C -> 65 veces - 0x46 -> 27 veces - 0x52 -> 11 veces - 0x21 -> 3 veces - -Offset 0x02A05 (10757): - Valores distintos (4): 0x00, 0x02, 0x0E, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x02 -> 57 veces - 0x3D -> 27 veces - 0x0E -> 1 veces - -Offset 0x02A06 (10758): - Valores distintos (3): 0x00, 0x0A, 0x47 - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x0A -> 55 veces - 0x47 -> 27 veces - -Offset 0x02A07 (10759): - Valores distintos (4): 0x00, 0x48, 0x4A, 0x4C - Clasificación: small_state - Más frecuentes: - 0x00 -> 153 veces - 0x4A -> 50 veces - 0x48 -> 27 veces - 0x4C -> 4 veces - -Offset 0x02A08 (10760): - Valores distintos (3): 0x00, 0x24, 0x3A - Clasificación: small_state - Más frecuentes: - 0x00 -> 157 veces - 0x3A -> 50 veces - 0x24 -> 27 veces - -Offset 0x02A09 (10761): - Valores distintos (3): 0x00, 0x0A, 0x24 - Clasificación: small_state - Más frecuentes: - 0x00 -> 160 veces - 0x24 -> 47 veces - 0x0A -> 27 veces - -Offset 0x02A0A (10762): - Valores distintos (3): 0x00, 0x08, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 160 veces - 0x0C -> 47 veces - 0x08 -> 27 veces - -Offset 0x02A0B (10763): - Valores distintos (3): 0x00, 0x09, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 161 veces - 0x11 -> 46 veces - 0x09 -> 27 veces - -Offset 0x02A0C (10764): - Valores distintos (4): 0x00, 0x07, 0x0E, 0x12 - Clasificación: small_state - Más frecuentes: - 0x00 -> 172 veces - 0x0E -> 34 veces - 0x07 -> 27 veces - 0x12 -> 1 veces - -Offset 0x02A0D (10765): - Valores distintos (3): 0x00, 0x21, 0x42 - Clasificación: small_state - Más frecuentes: - 0x00 -> 176 veces - 0x42 -> 31 veces - 0x21 -> 27 veces - -Offset 0x02A0E (10766): - Valores distintos (4): 0x00, 0x33, 0x3A, 0x52 - Clasificación: small_state - Más frecuentes: - 0x00 -> 179 veces - 0x3A -> 27 veces - 0x33 -> 14 veces - 0x52 -> 14 veces - -Offset 0x02A0F (10767): - Valores distintos (3): 0x00, 0x2A, 0x4C - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x4C -> 27 veces - 0x2A -> 27 veces - -Offset 0x02A10 (10768): - Valores distintos (3): 0x00, 0x06, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x3D -> 27 veces - 0x06 -> 27 veces - -Offset 0x02A11 (10769): - Valores distintos (3): 0x00, 0x20, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x4D -> 27 veces - 0x20 -> 27 veces - -Offset 0x02A12 (10770): - Valores distintos (3): 0x00, 0x14, 0x39 - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0x39 -> 27 veces - 0x14 -> 20 veces - -Offset 0x02A13 (10771): - Valores distintos (3): 0x00, 0x29, 0x4F - Clasificación: small_state - Más frecuentes: - 0x00 -> 190 veces - 0x29 -> 27 veces - 0x4F -> 17 veces - -Offset 0x02A14 (10772): - Valores distintos (3): 0x00, 0x04, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x04 -> 27 veces - 0x26 -> 13 veces - -Offset 0x02A15 (10773): - Valores distintos (3): 0x00, 0x08, 0x1F - Clasificación: small_state - Más frecuentes: - 0x00 -> 196 veces - 0x1F -> 27 veces - 0x08 -> 11 veces - -Offset 0x02A16 (10774): - Valores distintos (3): 0x00, 0x38, 0x40 - Clasificación: small_state - Más frecuentes: - 0x00 -> 200 veces - 0x38 -> 27 veces - 0x40 -> 7 veces - -Offset 0x02A17 (10775): - Valores distintos (3): 0x00, 0x03, 0x12 - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x03 -> 27 veces - 0x12 -> 6 veces - -Offset 0x02A18 (10776): - Valores distintos (3): 0x00, 0x02, 0x4E - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x02 -> 27 veces - 0x4E -> 6 veces - -Offset 0x02A19 (10777): - Valores distintos (2): 0x00, 0x1C - Clasificación: small_state - Más frecuentes: - 0x00 -> 207 veces - 0x1C -> 27 veces - -Offset 0x02A1A (10778): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x00 -> 212 veces - 0x4B -> 22 veces - -Offset 0x02A1B (10779): - Valores distintos (2): 0x00, 0x35 - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0x35 -> 20 veces - -Offset 0x02A1C (10780): - Valores distintos (2): 0x00, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0x16 -> 20 veces - -Offset 0x02A1D (10781): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 215 veces - 0x15 -> 19 veces - -Offset 0x02A74 (10868): - Valores distintos (6): 0x00, 0x21, 0x23, 0x32, 0x33, 0x36 - Clasificación: small_state - Más frecuentes: - 0x32 -> 165 veces - 0x00 -> 34 veces - 0x21 -> 13 veces - 0x23 -> 11 veces - 0x33 -> 10 veces - -Offset 0x02A75 (10869): - Valores distintos (7): 0x00, 0x05, 0x0C, 0x21, 0x32, 0x33, 0x36 - Clasificación: small_state - Más frecuentes: - 0x33 -> 92 veces - 0x21 -> 52 veces - 0x05 -> 40 veces - 0x00 -> 19 veces - 0x0C -> 13 veces - -Offset 0x02A76 (10870): - Valores distintos (10): 0x00, 0x03, 0x06, 0x08, 0x23, 0x29, 0x2B, 0x33, 0x36, 0x37 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 68 veces - 0x29 -> 47 veces - 0x36 -> 27 veces - 0x23 -> 26 veces - 0x33 -> 21 veces - -Offset 0x02A77 (10871): - Valores distintos (7): 0x00, 0x05, 0x06, 0x21, 0x26, 0x29, 0x38 - Clasificación: small_state - Más frecuentes: - 0x21 -> 86 veces - 0x06 -> 58 veces - 0x00 -> 49 veces - 0x38 -> 27 veces - 0x05 -> 12 veces - -Offset 0x02A78 (10872): - Valores distintos (7): 0x00, 0x03, 0x05, 0x06, 0x08, 0x23, 0x3E - Clasificación: small_state - Más frecuentes: - 0x23 -> 86 veces - 0x00 -> 81 veces - 0x3E -> 27 veces - 0x05 -> 25 veces - 0x03 -> 12 veces - -Offset 0x02A79 (10873): - Valores distintos (9): 0x00, 0x03, 0x05, 0x08, 0x11, 0x26, 0x29, 0x32, 0x3A - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 97 veces - 0x26 -> 65 veces - 0x3A -> 27 veces - 0x03 -> 25 veces - 0x08 -> 6 veces - -Offset 0x02A7A (10874): - Valores distintos (9): 0x00, 0x03, 0x06, 0x08, 0x0B, 0x26, 0x27, 0x36, 0x3D - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 91 veces - 0x36 -> 57 veces - 0x3D -> 27 veces - 0x08 -> 21 veces - 0x26 -> 21 veces - -Offset 0x02A7B (10875): - Valores distintos (7): 0x00, 0x06, 0x08, 0x0B, 0x0C, 0x23, 0x29 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x0C -> 65 veces - 0x29 -> 27 veces - 0x06 -> 21 veces - 0x0B -> 18 veces - -Offset 0x02A7C (10876): - Valores distintos (5): 0x00, 0x05, 0x0E, 0x11, 0x21 - Clasificación: small_state - Más frecuentes: - 0x00 -> 96 veces - 0x11 -> 65 veces - 0x21 -> 27 veces - 0x0E -> 25 veces - 0x05 -> 21 veces - -Offset 0x02A7D (10877): - Valores distintos (5): 0x00, 0x03, 0x06, 0x0C, 0x23 - Clasificación: small_state - Más frecuentes: - 0x00 -> 99 veces - 0x06 -> 65 veces - 0x23 -> 27 veces - 0x0C -> 22 veces - 0x03 -> 21 veces - -Offset 0x02A7E (10878): - Valores distintos (6): 0x00, 0x05, 0x08, 0x0A, 0x26, 0x29 - Clasificación: small_state - Más frecuentes: - 0x00 -> 100 veces - 0x05 -> 65 veces - 0x26 -> 39 veces - 0x08 -> 21 veces - 0x0A -> 8 veces - -Offset 0x02A7F (10879): - Valores distintos (7): 0x00, 0x03, 0x0E, 0x10, 0x27, 0x28, 0x29 - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0x03 -> 65 veces - 0x27 -> 27 veces - 0x0E -> 21 veces - 0x10 -> 9 veces - -Offset 0x02A80 (10880): - Valores distintos (3): 0x00, 0x08, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x08 -> 65 veces - 0x28 -> 27 veces - -Offset 0x02A81 (10881): - Valores distintos (4): 0x00, 0x0A, 0x0E, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 121 veces - 0x0E -> 65 veces - 0x2C -> 27 veces - 0x0A -> 21 veces - -Offset 0x02A82 (10882): - Valores distintos (4): 0x00, 0x0A, 0x0C, 0x10 - Clasificación: small_state - Más frecuentes: - 0x00 -> 134 veces - 0x0A -> 65 veces - 0x0C -> 27 veces - 0x10 -> 8 veces - -Offset 0x02A83 (10883): - Valores distintos (3): 0x00, 0x10, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x10 -> 65 veces - 0x11 -> 27 veces - -Offset 0x02A84 (10884): - Valores distintos (3): 0x00, 0x06, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x0B -> 65 veces - 0x06 -> 27 veces - -Offset 0x02A85 (10885): - Valores distintos (5): 0x00, 0x05, 0x14, 0x27, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x27 -> 39 veces - 0x05 -> 27 veces - 0x38 -> 16 veces - 0x14 -> 1 veces - -Offset 0x02A86 (10886): - Valores distintos (4): 0x00, 0x03, 0x3B, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x3E -> 54 veces - 0x03 -> 27 veces - 0x3B -> 1 veces - -Offset 0x02A87 (10887): - Valores distintos (5): 0x00, 0x08, 0x17, 0x3A, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0x3A -> 31 veces - 0x08 -> 27 veces - 0x17 -> 16 veces - 0x3E -> 1 veces - -Offset 0x02A88 (10888): - Valores distintos (3): 0x00, 0x0E, 0x12 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x12 -> 27 veces - 0x0E -> 27 veces - -Offset 0x02A89 (10889): - Valores distintos (3): 0x00, 0x0A, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x16 -> 27 veces - 0x0A -> 27 veces - -Offset 0x02A8A (10890): - Valores distintos (4): 0x00, 0x10, 0x14, 0x1A - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0x10 -> 27 veces - 0x14 -> 17 veces - 0x1A -> 3 veces - -Offset 0x02A8B (10891): - Valores distintos (5): 0x00, 0x0B, 0x27, 0x3B, 0x3C - Clasificación: small_state - Más frecuentes: - 0x00 -> 185 veces - 0x0B -> 27 veces - 0x27 -> 13 veces - 0x3B -> 8 veces - 0x3C -> 1 veces - -Offset 0x02A8C (10892): - Valores distintos (3): 0x00, 0x17, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x17 -> 27 veces - 0x28 -> 13 veces - -Offset 0x02A8D (10893): - Valores distintos (4): 0x00, 0x12, 0x3A, 0x3F - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x12 -> 27 veces - 0x3F -> 4 veces - 0x3A -> 2 veces - -Offset 0x02A8E (10894): - Valores distintos (3): 0x00, 0x16, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x16 -> 27 veces - 0x3D -> 6 veces - -Offset 0x02A8F (10895): - Valores distintos (4): 0x00, 0x14, 0x2A, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x14 -> 27 veces - 0x2A -> 4 veces - 0x2C -> 2 veces - -Offset 0x02A90 (10896): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 205 veces - 0x15 -> 29 veces - -Offset 0x02A91 (10897): - Valores distintos (2): 0x00, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 210 veces - 0x2A -> 24 veces - -Offset 0x02A92 (10898): - Valores distintos (2): 0x00, 0x3B - Clasificación: small_state - Más frecuentes: - 0x00 -> 212 veces - 0x3B -> 22 veces - -Offset 0x02A93 (10899): - Valores distintos (2): 0x00, 0x2B - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0x2B -> 20 veces - -Offset 0x02A94 (10900): - Valores distintos (2): 0x00, 0x1E - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0x1E -> 20 veces - -Offset 0x02AF4 (10996): - Valores distintos (4): 0x00, 0x18, 0x1C, 0x21 - Clasificación: small_state - Más frecuentes: - 0x18 -> 151 veces - 0x1C -> 47 veces - 0x21 -> 31 veces - 0x00 -> 5 veces - -Offset 0x02AF5 (10997): - Valores distintos (5): 0x00, 0x09, 0x0A, 0x1F, 0x25 - Clasificación: small_state - Más frecuentes: - 0x09 -> 114 veces - 0x1F -> 40 veces - 0x0A -> 34 veces - 0x25 -> 26 veces - 0x00 -> 20 veces - -Offset 0x02AF6 (10998): - Valores distintos (8): 0x00, 0x05, 0x09, 0x11, 0x12, 0x1C, 0x28, 0x29 - Clasificación: small_state - Más frecuentes: - 0x11 -> 58 veces - 0x05 -> 53 veces - 0x00 -> 35 veces - 0x1C -> 31 veces - 0x28 -> 28 veces - -Offset 0x02AF7 (10999): - Valores distintos (7): 0x00, 0x04, 0x09, 0x0E, 0x13, 0x1D, 0x1F - Clasificación: small_state - Más frecuentes: - 0x13 -> 57 veces - 0x04 -> 53 veces - 0x00 -> 44 veces - 0x1F -> 31 veces - 0x1D -> 25 veces - -Offset 0x02AF8 (11000): - Valores distintos (10): 0x00, 0x01, 0x02, 0x05, 0x0C, 0x0E, 0x12, 0x24, 0x28, 0x29 - Clasificación: bitfield_like - Más frecuentes: - 0x12 -> 92 veces - 0x00 -> 48 veces - 0x28 -> 31 veces - 0x05 -> 21 veces - 0x24 -> 19 veces - -Offset 0x02AF9 (11001): - Valores distintos (11): 0x00, 0x02, 0x04, 0x05, 0x09, 0x0E, 0x12, 0x18, 0x1D, 0x21, 0x29 - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 79 veces - 0x00 -> 62 veces - 0x1D -> 31 veces - 0x29 -> 21 veces - 0x12 -> 13 veces - -Offset 0x02AFA (11002): - Valores distintos (8): 0x00, 0x0A, 0x0E, 0x21, 0x24, 0x25, 0x29, 0x2F - Clasificación: small_state - Más frecuentes: - 0x29 -> 65 veces - 0x00 -> 46 veces - 0x21 -> 37 veces - 0x24 -> 31 veces - 0x0A -> 27 veces - -Offset 0x02AFB (11003): - Valores distintos (8): 0x00, 0x10, 0x1C, 0x21, 0x25, 0x29, 0x2E, 0x2F - Clasificación: small_state - Más frecuentes: - 0x21 -> 65 veces - 0x00 -> 52 veces - 0x25 -> 37 veces - 0x10 -> 27 veces - 0x2F -> 23 veces - -Offset 0x02AFC (11004): - Valores distintos (8): 0x00, 0x08, 0x12, 0x18, 0x1C, 0x1F, 0x21, 0x25 - Clasificación: small_state - Más frecuentes: - 0x25 -> 65 veces - 0x00 -> 60 veces - 0x1C -> 37 veces - 0x08 -> 27 veces - 0x21 -> 21 veces - -Offset 0x02AFD (11005): - Valores distintos (7): 0x00, 0x16, 0x1C, 0x1F, 0x25, 0x28, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 70 veces - 0x1C -> 65 veces - 0x1F -> 37 veces - 0x16 -> 27 veces - 0x25 -> 21 veces - -Offset 0x02AFE (11006): - Valores distintos (7): 0x00, 0x06, 0x1C, 0x1D, 0x1F, 0x20, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 73 veces - 0x1F -> 65 veces - 0x28 -> 37 veces - 0x06 -> 27 veces - 0x1C -> 21 veces - -Offset 0x02AFF (11007): - Valores distintos (8): 0x00, 0x02, 0x0A, 0x0C, 0x1D, 0x1F, 0x24, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 74 veces - 0x28 -> 65 veces - 0x1D -> 37 veces - 0x1F -> 21 veces - 0x0C -> 14 veces - -Offset 0x02B00 (11008): - Valores distintos (7): 0x00, 0x0B, 0x1B, 0x1D, 0x24, 0x28, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 90 veces - 0x1D -> 65 veces - 0x24 -> 37 veces - 0x28 -> 21 veces - 0x0B -> 14 veces - -Offset 0x02B01 (11009): - Valores distintos (6): 0x00, 0x1D, 0x20, 0x24, 0x29, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 83 veces - 0x24 -> 65 veces - 0x2C -> 37 veces - 0x29 -> 27 veces - 0x1D -> 21 veces - -Offset 0x02B02 (11010): - Valores distintos (6): 0x00, 0x20, 0x21, 0x22, 0x24, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 83 veces - 0x2C -> 65 veces - 0x20 -> 37 veces - 0x21 -> 27 veces - 0x24 -> 21 veces - -Offset 0x02B03 (11011): - Valores distintos (6): 0x00, 0x20, 0x22, 0x25, 0x2C, 0x2E - Clasificación: small_state - Más frecuentes: - 0x00 -> 83 veces - 0x20 -> 65 veces - 0x25 -> 27 veces - 0x22 -> 21 veces - 0x2C -> 21 veces - -Offset 0x02B04 (11012): - Valores distintos (6): 0x00, 0x1C, 0x20, 0x22, 0x2E, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 98 veces - 0x22 -> 66 veces - 0x1C -> 27 veces - 0x2E -> 21 veces - 0x20 -> 21 veces - -Offset 0x02B05 (11013): - Valores distintos (5): 0x00, 0x1F, 0x22, 0x2E, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x2E -> 65 veces - 0x1F -> 27 veces - 0x22 -> 21 veces - 0x30 -> 16 veces - -Offset 0x02B06 (11014): - Valores distintos (5): 0x00, 0x04, 0x28, 0x2E, 0x2F - Clasificación: small_state - Más frecuentes: - 0x00 -> 114 veces - 0x2F -> 65 veces - 0x28 -> 27 veces - 0x2E -> 21 veces - 0x04 -> 7 veces - -Offset 0x02B07 (11015): - Valores distintos (4): 0x00, 0x1D, 0x1E, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 124 veces - 0x1E -> 62 veces - 0x1D -> 27 veces - 0x30 -> 21 veces - -Offset 0x02B08 (11016): - Valores distintos (3): 0x00, 0x24, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 145 veces - 0x26 -> 62 veces - 0x24 -> 27 veces - -Offset 0x02B09 (11017): - Valores distintos (4): 0x00, 0x0A, 0x0C, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 150 veces - 0x0A -> 34 veces - 0x2C -> 27 veces - 0x0C -> 23 veces - -Offset 0x02B0A (11018): - Valores distintos (3): 0x00, 0x10, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 150 veces - 0x10 -> 57 veces - 0x20 -> 27 veces - -Offset 0x02B0B (11019): - Valores distintos (4): 0x00, 0x02, 0x22, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x30 -> 48 veces - 0x22 -> 27 veces - 0x02 -> 7 veces - -Offset 0x02B0C (11020): - Valores distintos (4): 0x00, 0x01, 0x1E, 0x2B - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x2B -> 48 veces - 0x1E -> 27 veces - 0x01 -> 7 veces - -Offset 0x02B0D (11021): - Valores distintos (4): 0x00, 0x26, 0x31, 0x32 - Clasificación: small_state - Más frecuentes: - 0x00 -> 188 veces - 0x26 -> 27 veces - 0x32 -> 11 veces - 0x31 -> 8 veces - -Offset 0x02B0E (11022): - Valores distintos (4): 0x00, 0x08, 0x14, 0x2B - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0x2B -> 27 veces - 0x14 -> 8 veces - 0x08 -> 8 veces - -Offset 0x02B0F (11023): - Valores distintos (3): 0x00, 0x16, 0x23 - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0x23 -> 27 veces - 0x16 -> 16 veces - -Offset 0x02B10 (11024): - Valores distintos (4): 0x00, 0x08, 0x23, 0x2E - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x2E -> 27 veces - 0x23 -> 8 veces - 0x08 -> 5 veces - -Offset 0x02B11 (11025): - Valores distintos (3): 0x00, 0x06, 0x2F - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x2F -> 27 veces - 0x06 -> 13 veces - -Offset 0x02B12 (11026): - Valores distintos (4): 0x00, 0x0C, 0x14, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 199 veces - 0x30 -> 27 veces - 0x0C -> 7 veces - 0x14 -> 1 veces - -Offset 0x02B13 (11027): - Valores distintos (3): 0x00, 0x14, 0x32 - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x32 -> 27 veces - 0x14 -> 6 veces - -Offset 0x02B14 (11028): - Valores distintos (2): 0x00, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x0F -> 25 veces - -Offset 0x02B15 (11029): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x15 -> 25 veces - -Offset 0x02B16 (11030): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x05 -> 25 veces - -Offset 0x02B17 (11031): - Valores distintos (2): 0x00, 0x19 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x19 -> 25 veces - -Offset 0x02B18 (11032): - Valores distintos (3): 0x00, 0x0C, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 216 veces - 0x14 -> 13 veces - 0x0C -> 5 veces - -Offset 0x02B74 (11124): - Valores distintos (24): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x12, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E - Clasificación: bitfield_like - Más frecuentes: - 0x03 -> 47 veces - 0x08 -> 23 veces - 0x09 -> 23 veces - 0x1B -> 22 veces - 0x1A -> 20 veces - -Offset 0x02B75 (11125): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x09, 0x0A - Clasificación: small_state - Más frecuentes: - 0x01 -> 90 veces - 0x02 -> 76 veces - 0x03 -> 34 veces - 0x0A -> 15 veces - 0x09 -> 11 veces - -Offset 0x02B76 (11126): - Valores distintos (28): 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0D, 0x0E, 0x13, 0x14, 0x15, 0x17, 0x18, 0x1B, 0x1C, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x25, 0x26, 0x27, 0x28 - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 74 veces - 0x21 -> 45 veces - 0x20 -> 18 veces - 0x02 -> 13 veces - 0x13 -> 12 veces - -Offset 0x02B77 (11127): - Valores distintos (23): 0x00, 0x01, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x10, 0x12, 0x13, 0x14, 0x17, 0x19, 0x1A, 0x1D, 0x1E, 0x1F, 0x20 - Clasificación: bitfield_like - Más frecuentes: - 0x17 -> 34 veces - 0x19 -> 33 veces - 0x20 -> 25 veces - 0x1A -> 19 veces - 0x10 -> 16 veces - -Offset 0x02B78 (11128): - Valores distintos (19): 0x00, 0x01, 0x02, 0x03, 0x04, 0x06, 0x07, 0x08, 0x09, 0x0B, 0x0C, 0x0D, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 - Clasificación: bitfield_like - Más frecuentes: - 0x16 -> 60 veces - 0x0C -> 37 veces - 0x01 -> 19 veces - 0x13 -> 19 veces - 0x06 -> 16 veces - -Offset 0x02B79 (11129): - Valores distintos (11): 0x00, 0x01, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0D - Clasificación: bitfield_like - Más frecuentes: - 0x0B -> 39 veces - 0x06 -> 37 veces - 0x0D -> 37 veces - 0x01 -> 32 veces - 0x0A -> 21 veces - -Offset 0x02B7A (11130): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 182 veces - 0x02 -> 25 veces - 0x04 -> 14 veces - 0x00 -> 10 veces - 0x03 -> 3 veces - -Offset 0x02B7B (11131): - Valores distintos (5): 0x00, 0x01, 0x03, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x06 -> 135 veces - 0x03 -> 34 veces - 0x01 -> 32 veces - 0x05 -> 23 veces - 0x00 -> 10 veces - -Offset 0x02B7C (11132): - Valores distintos (12): 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0D, 0x0E, 0x0F - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 58 veces - 0x03 -> 47 veces - 0x02 -> 43 veces - 0x0D -> 23 veces - 0x01 -> 18 veces - -Offset 0x02B7D (11133): - Valores distintos (9): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 - Clasificación: bitfield_like - Más frecuentes: - 0x01 -> 66 veces - 0x03 -> 63 veces - 0x02 -> 23 veces - 0x05 -> 21 veces - 0x06 -> 17 veces - -Offset 0x02B7E (11134): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 75 veces - 0x02 -> 70 veces - 0x00 -> 35 veces - 0x03 -> 28 veces - 0x04 -> 26 veces - -Offset 0x02B7F (11135): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x04, 0x0D - Clasificación: small_state - Más frecuentes: - 0x0D -> 114 veces - 0x01 -> 59 veces - 0x02 -> 34 veces - 0x00 -> 17 veces - 0x04 -> 6 veces - -Offset 0x02B80 (11136): - Valores distintos (8): 0x00, 0x01, 0x04, 0x05, 0x06, 0x0B, 0x0D, 0x0E - Clasificación: small_state - Más frecuentes: - 0x04 -> 124 veces - 0x0D -> 41 veces - 0x01 -> 27 veces - 0x06 -> 17 veces - 0x00 -> 15 veces - -Offset 0x02B81 (11137): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x01 -> 162 veces - 0x04 -> 43 veces - 0x00 -> 16 veces - 0x06 -> 6 veces - 0x03 -> 4 veces - -Offset 0x02B82 (11138): - Valores distintos (12): 0x00, 0x01, 0x02, 0x10, 0x11, 0x12, 0x13, 0x14, 0x16, 0x17, 0x1A, 0x1B - Clasificación: bitfield_like - Más frecuentes: - 0x02 -> 117 veces - 0x01 -> 69 veces - 0x00 -> 20 veces - 0x1B -> 10 veces - 0x1A -> 7 veces - -Offset 0x02B83 (11139): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x04 -> 114 veces - 0x01 -> 73 veces - 0x02 -> 27 veces - 0x00 -> 20 veces - -Offset 0x02B84 (11140): - Valores distintos (4): 0x00, 0x01, 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x01 -> 133 veces - 0x00 -> 43 veces - 0x02 -> 31 veces - 0x05 -> 27 veces - -Offset 0x02B85 (11141): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x05 -> 75 veces - 0x01 -> 66 veces - 0x00 -> 42 veces - 0x02 -> 30 veces - 0x04 -> 21 veces - -Offset 0x02B86 (11142): - Valores distintos (4): 0x00, 0x01, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x01 -> 161 veces - 0x00 -> 42 veces - 0x04 -> 19 veces - 0x05 -> 12 veces - -Offset 0x02B87 (11143): - Valores distintos (5): 0x00, 0x01, 0x02, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x01 -> 122 veces - 0x00 -> 46 veces - 0x02 -> 39 veces - 0x06 -> 23 veces - 0x07 -> 4 veces - -Offset 0x02B88 (11144): - Valores distintos (8): 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07, 0x09 - Clasificación: small_state - Más frecuentes: - 0x01 -> 70 veces - 0x00 -> 46 veces - 0x04 -> 39 veces - 0x05 -> 32 veces - 0x06 -> 21 veces - -Offset 0x02B89 (11145): - Valores distintos (10): 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0D - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 75 veces - 0x01 -> 40 veces - 0x08 -> 37 veces - 0x09 -> 24 veces - 0x05 -> 23 veces - -Offset 0x02B8A (11146): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x08, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 75 veces - 0x08 -> 59 veces - 0x01 -> 40 veces - 0x03 -> 26 veces - 0x02 -> 23 veces - -Offset 0x02B8B (11147): - Valores distintos (5): 0x00, 0x01, 0x06, 0x0A, 0x54 - Clasificación: small_state - Más frecuentes: - 0x01 -> 119 veces - 0x00 -> 75 veces - 0x54 -> 27 veces - 0x06 -> 12 veces - 0x0A -> 1 veces - -Offset 0x02B8C (11148): - Valores distintos (6): 0x00, 0x01, 0x02, 0x04, 0x05, 0x0A - Clasificación: small_state - Más frecuentes: - 0x0A -> 87 veces - 0x00 -> 76 veces - 0x01 -> 23 veces - 0x02 -> 21 veces - 0x05 -> 20 veces - -Offset 0x02B8D (11149): - Valores distintos (5): 0x00, 0x01, 0x02, 0x1C, 0x1D - Clasificación: small_state - Más frecuentes: - 0x1C -> 96 veces - 0x00 -> 76 veces - 0x01 -> 57 veces - 0x1D -> 4 veces - 0x02 -> 1 veces - -Offset 0x02B8E (11150): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 76 veces - 0x03 -> 58 veces - 0x02 -> 41 veces - 0x04 -> 21 veces - 0x05 -> 19 veces - -Offset 0x02B8F (11151): - Valores distintos (5): 0x00, 0x01, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x03 -> 87 veces - 0x00 -> 76 veces - 0x01 -> 44 veces - 0x05 -> 17 veces - 0x04 -> 10 veces - -Offset 0x02B90 (11152): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x1C - Clasificación: small_state - Más frecuentes: - 0x02 -> 97 veces - 0x00 -> 76 veces - 0x01 -> 31 veces - 0x03 -> 24 veces - 0x1C -> 6 veces - -Offset 0x02B91 (11153): - Valores distintos (6): 0x00, 0x01, 0x02, 0x04, 0x07, 0x08 - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 76 veces - 0x08 -> 20 veces - 0x07 -> 7 veces - 0x04 -> 4 veces - -Offset 0x02B92 (11154): - Valores distintos (11): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 76 veces - 0x03 -> 38 veces - 0x02 -> 31 veces - 0x0A -> 21 veces - 0x01 -> 18 veces - -Offset 0x02B93 (11155): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 113 veces - 0x00 -> 76 veces - 0x02 -> 39 veces - 0x04 -> 4 veces - 0x03 -> 2 veces - -Offset 0x02B94 (11156): - Valores distintos (8): 0x00, 0x01, 0x02, 0x07, 0x08, 0x09, 0x0A, 0x1C - Clasificación: small_state - Más frecuentes: - 0x00 -> 78 veces - 0x08 -> 58 veces - 0x07 -> 24 veces - 0x1C -> 21 veces - 0x0A -> 17 veces - -Offset 0x02B95 (11157): - Valores distintos (6): 0x00, 0x01, 0x02, 0x04, 0x05, 0x0A - Clasificación: small_state - Más frecuentes: - 0x01 -> 89 veces - 0x00 -> 79 veces - 0x02 -> 38 veces - 0x04 -> 22 veces - 0x05 -> 5 veces - -Offset 0x02B96 (11158): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x22, 0x23 - Clasificación: small_state - Más frecuentes: - 0x00 -> 79 veces - 0x03 -> 48 veces - 0x01 -> 43 veces - 0x02 -> 37 veces - 0x22 -> 17 veces - -Offset 0x02B97 (11159): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 90 veces - 0x01 -> 81 veces - 0x04 -> 26 veces - 0x02 -> 20 veces - 0x03 -> 17 veces - -Offset 0x02B98 (11160): - Valores distintos (10): 0x00, 0x01, 0x02, 0x04, 0x0A, 0x0B, 0x0E, 0x10, 0x54, 0x63 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 90 veces - 0x54 -> 59 veces - 0x01 -> 25 veces - 0x02 -> 21 veces - 0x10 -> 20 veces - -Offset 0x02B99 (11161): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 93 veces - 0x04 -> 65 veces - 0x02 -> 51 veces - 0x01 -> 21 veces - 0x03 -> 4 veces - -Offset 0x02B9A (11162): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 108 veces - 0x00 -> 95 veces - 0x02 -> 28 veces - 0x03 -> 3 veces - -Offset 0x02B9B (11163): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x02 -> 67 veces - 0x01 -> 44 veces - 0x0A -> 27 veces - 0x04 -> 1 veces - -Offset 0x02B9C (11164): - Valores distintos (11): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0A, 0x1D - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 95 veces - 0x03 -> 45 veces - 0x1D -> 27 veces - 0x02 -> 22 veces - 0x04 -> 13 veces - -Offset 0x02B9D (11165): - Valores distintos (4): 0x00, 0x01, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 95 veces - 0x01 -> 91 veces - 0x03 -> 31 veces - 0x04 -> 17 veces - -Offset 0x02B9E (11166): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 99 veces - 0x02 -> 45 veces - 0x03 -> 27 veces - 0x04 -> 25 veces - 0x01 -> 21 veces - -Offset 0x02B9F (11167): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 99 veces - 0x01 -> 86 veces - 0x02 -> 27 veces - 0x04 -> 22 veces - -Offset 0x02BA0 (11168): - Valores distintos (9): 0x00, 0x01, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 103 veces - 0x01 -> 46 veces - 0x08 -> 23 veces - 0x03 -> 21 veces - 0x04 -> 12 veces - -Offset 0x02BA1 (11169): - Valores distintos (5): 0x00, 0x01, 0x04, 0x05, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 118 veces - 0x05 -> 55 veces - 0x09 -> 27 veces - 0x01 -> 24 veces - 0x04 -> 10 veces - -Offset 0x02BA2 (11170): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x01 -> 87 veces - 0x02 -> 27 veces - -Offset 0x02BA3 (11171): - Valores distintos (4): 0x00, 0x01, 0x02, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x01 -> 52 veces - 0x02 -> 28 veces - 0x0A -> 27 veces - -Offset 0x02BA4 (11172): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x01 -> 57 veces - 0x02 -> 35 veces - -Offset 0x02BA5 (11173): - Valores distintos (5): 0x00, 0x02, 0x03, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x0A -> 59 veces - 0x03 -> 27 veces - 0x02 -> 4 veces - 0x0B -> 2 veces - -Offset 0x02BA6 (11174): - Valores distintos (4): 0x00, 0x01, 0x08, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 143 veces - 0x08 -> 59 veces - 0x01 -> 27 veces - 0x0C -> 5 veces - -Offset 0x02BA7 (11175): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x04, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 164 veces - 0x09 -> 27 veces - 0x04 -> 20 veces - 0x03 -> 16 veces - 0x02 -> 4 veces - -Offset 0x02BA8 (11176): - Valores distintos (6): 0x00, 0x05, 0x1A, 0x1B, 0x1D, 0x1F - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0x05 -> 27 veces - 0x1B -> 8 veces - 0x1D -> 6 veces - 0x1A -> 4 veces - -Offset 0x02BA9 (11177): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 187 veces - 0x01 -> 47 veces - -Offset 0x02BAA (11178): - Valores distintos (4): 0x00, 0x01, 0x04, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 203 veces - 0x0A -> 27 veces - 0x01 -> 2 veces - 0x04 -> 2 veces - -Offset 0x02BAB (11179): - Valores distintos (3): 0x00, 0x01, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x09 -> 20 veces - 0x01 -> 1 veces - -Offset 0x02BF4 (11252): - Valores distintos (4): 0x00, 0x01, 0x03, 0x06 - Clasificación: small_state - Más frecuentes: - 0x01 -> 216 veces - 0x03 -> 9 veces - 0x00 -> 6 veces - 0x06 -> 3 veces - -Offset 0x02BF5 (11253): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 197 veces - 0x03 -> 21 veces - 0x00 -> 16 veces - -Offset 0x02BF6 (11254): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 159 veces - 0x03 -> 51 veces - 0x00 -> 24 veces - -Offset 0x02BF7 (11255): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 117 veces - 0x03 -> 65 veces - 0x00 -> 48 veces - 0x02 -> 4 veces - -Offset 0x02BF8 (11256): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 125 veces - 0x00 -> 71 veces - 0x02 -> 38 veces - -Offset 0x02BF9 (11257): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 89 veces - 0x00 -> 74 veces - 0x02 -> 71 veces - -Offset 0x02BFA (11258): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 113 veces - 0x00 -> 72 veces - 0x04 -> 27 veces - 0x02 -> 22 veces - -Offset 0x02BFB (11259): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 72 veces - 0x04 -> 55 veces - 0x01 -> 54 veces - 0x02 -> 50 veces - 0x03 -> 3 veces - -Offset 0x02BFC (11260): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 97 veces - 0x00 -> 72 veces - 0x02 -> 65 veces - -Offset 0x02BFD (11261): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 158 veces - 0x00 -> 76 veces - -Offset 0x02BFE (11262): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 139 veces - 0x00 -> 80 veces - 0x03 -> 11 veces - 0x02 -> 4 veces - -Offset 0x02BFF (11263): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 80 veces - 0x03 -> 65 veces - 0x01 -> 62 veces - 0x02 -> 27 veces - -Offset 0x02C00 (11264): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 150 veces - 0x00 -> 84 veces - -Offset 0x02C01 (11265): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 141 veces - 0x00 -> 93 veces - -Offset 0x02C02 (11266): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 139 veces - 0x00 -> 95 veces - -Offset 0x02C03 (11267): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 138 veces - 0x00 -> 96 veces - -Offset 0x02C04 (11268): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 127 veces - 0x01 -> 107 veces - -Offset 0x02C05 (11269): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 149 veces - 0x01 -> 85 veces - -Offset 0x02C06 (11270): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x01 -> 55 veces - 0x03 -> 27 veces - -Offset 0x02C07 (11271): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 153 veces - 0x01 -> 81 veces - -Offset 0x02C08 (11272): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 157 veces - 0x01 -> 77 veces - -Offset 0x02C09 (11273): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 160 veces - 0x01 -> 74 veces - -Offset 0x02C0A (11274): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 160 veces - 0x01 -> 47 veces - 0x02 -> 27 veces - -Offset 0x02C0B (11275): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 161 veces - 0x01 -> 73 veces - -Offset 0x02C0C (11276): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 172 veces - 0x01 -> 35 veces - 0x02 -> 27 veces - -Offset 0x02C0D (11277): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 176 veces - 0x01 -> 58 veces - -Offset 0x02C0E (11278): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 179 veces - 0x01 -> 55 veces - -Offset 0x02C0F (11279): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 180 veces - 0x01 -> 54 veces - -Offset 0x02C10 (11280): - Valores distintos (3): 0x00, 0x01, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x01 -> 27 veces - 0x04 -> 27 veces - -Offset 0x02C11 (11281): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x01 -> 27 veces - 0x02 -> 27 veces - -Offset 0x02C12 (11282): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 187 veces - 0x01 -> 47 veces - -Offset 0x02C13 (11283): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 190 veces - 0x01 -> 44 veces - -Offset 0x02C14 (11284): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x03 -> 27 veces - 0x01 -> 13 veces - -Offset 0x02C15 (11285): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 196 veces - 0x01 -> 33 veces - 0x02 -> 5 veces - -Offset 0x02C16 (11286): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 200 veces - 0x01 -> 32 veces - 0x02 -> 2 veces - -Offset 0x02C17 (11287): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 201 veces - 0x01 -> 33 veces - -Offset 0x02C18 (11288): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 201 veces - 0x01 -> 33 veces - -Offset 0x02C19 (11289): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 207 veces - 0x01 -> 27 veces - -Offset 0x02C1A (11290): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 212 veces - 0x01 -> 22 veces - -Offset 0x02C1B (11291): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 214 veces - 0x01 -> 20 veces - -Offset 0x02C1C (11292): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 214 veces - 0x01 -> 20 veces - -Offset 0x02C1D (11293): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 215 veces - 0x01 -> 19 veces - -Offset 0x02C74 (11380): - Valores distintos (4): 0x00, 0x01, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 170 veces - 0x00 -> 34 veces - 0x04 -> 27 veces - 0x03 -> 3 veces - -Offset 0x02C75 (11381): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 205 veces - 0x00 -> 19 veces - 0x02 -> 10 veces - -Offset 0x02C76 (11382): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 127 veces - 0x00 -> 68 veces - 0x03 -> 39 veces - -Offset 0x02C77 (11383): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x02 -> 100 veces - 0x01 -> 64 veces - 0x00 -> 49 veces - 0x03 -> 21 veces - -Offset 0x02C78 (11384): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 119 veces - 0x00 -> 81 veces - 0x02 -> 33 veces - 0x03 -> 1 veces - -Offset 0x02C79 (11385): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 100 veces - 0x00 -> 97 veces - 0x02 -> 37 veces - -Offset 0x02C7A (11386): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 91 veces - 0x01 -> 73 veces - 0x02 -> 51 veces - 0x03 -> 19 veces - -Offset 0x02C7B (11387): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 114 veces - 0x00 -> 97 veces - 0x03 -> 22 veces - 0x02 -> 1 veces - -Offset 0x02C7C (11388): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 103 veces - 0x00 -> 96 veces - 0x02 -> 35 veces - -Offset 0x02C7D (11389): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 99 veces - 0x03 -> 65 veces - 0x01 -> 49 veces - 0x02 -> 21 veces - -Offset 0x02C7E (11390): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 100 veces - 0x01 -> 86 veces - 0x02 -> 27 veces - 0x03 -> 21 veces - -Offset 0x02C7F (11391): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0x02 -> 58 veces - 0x01 -> 40 veces - 0x03 -> 28 veces - -Offset 0x02C80 (11392): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x03 -> 65 veces - 0x01 -> 27 veces - -Offset 0x02C81 (11393): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 121 veces - 0x02 -> 41 veces - 0x06 -> 31 veces - 0x01 -> 27 veces - 0x05 -> 7 veces - -Offset 0x02C82 (11394): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 134 veces - 0x02 -> 67 veces - 0x01 -> 27 veces - 0x03 -> 6 veces - -Offset 0x02C83 (11395): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x03 -> 59 veces - 0x01 -> 27 veces - 0x02 -> 6 veces - -Offset 0x02C84 (11396): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x01 -> 65 veces - 0x03 -> 27 veces - -Offset 0x02C85 (11397): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x02C86 (11398): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x01 -> 30 veces - 0x03 -> 27 veces - 0x02 -> 25 veces - -Offset 0x02C87 (11399): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0x01 -> 48 veces - 0x03 -> 27 veces - -Offset 0x02C88 (11400): - Valores distintos (8): 0x00, 0x01, 0x02, 0x03, 0x06, 0x07, 0x08, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x06 -> 17 veces - 0x03 -> 16 veces - 0x01 -> 7 veces - 0x09 -> 5 veces - -Offset 0x02C89 (11401): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x02 -> 28 veces - 0x01 -> 26 veces - -Offset 0x02C8A (11402): - Valores distintos (4): 0x00, 0x01, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 187 veces - 0x01 -> 20 veces - 0x03 -> 18 veces - 0x04 -> 9 veces - -Offset 0x02C8B (11403): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 185 veces - 0x01 -> 49 veces - -Offset 0x02C8C (11404): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x02 -> 24 veces - 0x01 -> 16 veces - -Offset 0x02C8D (11405): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x03 -> 27 veces - 0x01 -> 6 veces - -Offset 0x02C8E (11406): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 201 veces - 0x01 -> 33 veces - -Offset 0x02C8F (11407): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 201 veces - 0x01 -> 33 veces - -Offset 0x02C90 (11408): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 205 veces - 0x01 -> 29 veces - -Offset 0x02C91 (11409): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 210 veces - 0x02 -> 22 veces - 0x01 -> 2 veces - -Offset 0x02C92 (11410): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 212 veces - 0x01 -> 22 veces - -Offset 0x02C93 (11411): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 214 veces - 0x01 -> 20 veces - -Offset 0x02C94 (11412): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 214 veces - 0x01 -> 20 veces - -Offset 0x02CF4 (11508): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x03 -> 92 veces - 0x02 -> 86 veces - 0x01 -> 26 veces - 0x0B -> 20 veces - 0x00 -> 5 veces - -Offset 0x02CF5 (11509): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 188 veces - 0x03 -> 23 veces - 0x00 -> 20 veces - 0x02 -> 3 veces - -Offset 0x02CF6 (11510): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x01 -> 137 veces - 0x00 -> 35 veces - 0x03 -> 30 veces - 0x05 -> 21 veces - 0x04 -> 7 veces - -Offset 0x02CF7 (11511): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 155 veces - 0x00 -> 44 veces - 0x02 -> 25 veces - 0x03 -> 10 veces - -Offset 0x02CF8 (11512): - Valores distintos (7): 0x00, 0x01, 0x05, 0x07, 0x08, 0x09, 0x0B - Clasificación: small_state - Más frecuentes: - 0x01 -> 154 veces - 0x00 -> 48 veces - 0x05 -> 11 veces - 0x09 -> 9 veces - 0x08 -> 7 veces - -Offset 0x02CF9 (11513): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x06, 0x08, 0x09 - Clasificación: small_state - Más frecuentes: - 0x01 -> 119 veces - 0x00 -> 62 veces - 0x03 -> 30 veces - 0x06 -> 18 veces - 0x08 -> 2 veces - -Offset 0x02CFA (11514): - Valores distintos (12): 0x00, 0x01, 0x02, 0x03, 0x06, 0x07, 0x09, 0x13, 0x14, 0x15, 0x16, 0x17 - Clasificación: bitfield_like - Más frecuentes: - 0x15 -> 53 veces - 0x01 -> 47 veces - 0x00 -> 46 veces - 0x02 -> 22 veces - 0x06 -> 21 veces - -Offset 0x02CFB (11515): - Valores distintos (8): 0x00, 0x01, 0x03, 0x05, 0x07, 0x0B, 0x14, 0x15 - Clasificación: small_state - Más frecuentes: - 0x15 -> 74 veces - 0x01 -> 58 veces - 0x00 -> 52 veces - 0x07 -> 28 veces - 0x03 -> 9 veces - -Offset 0x02CFC (11516): - Valores distintos (7): 0x00, 0x01, 0x03, 0x04, 0x05, 0x09, 0x14 - Clasificación: small_state - Más frecuentes: - 0x14 -> 78 veces - 0x00 -> 60 veces - 0x04 -> 42 veces - 0x01 -> 24 veces - 0x05 -> 21 veces - -Offset 0x02CFD (11517): - Valores distintos (7): 0x00, 0x01, 0x02, 0x07, 0x10, 0x11, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 70 veces - 0x11 -> 61 veces - 0x01 -> 52 veces - 0x02 -> 25 veces - 0x14 -> 13 veces - -Offset 0x02CFE (11518): - Valores distintos (7): 0x00, 0x01, 0x04, 0x05, 0x07, 0x0D, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 73 veces - 0x01 -> 67 veces - 0x07 -> 37 veces - 0x04 -> 25 veces - 0x05 -> 21 veces - -Offset 0x02CFF (11519): - Valores distintos (7): 0x00, 0x01, 0x03, 0x07, 0x0C, 0x0D, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 74 veces - 0x07 -> 65 veces - 0x01 -> 57 veces - 0x0D -> 25 veces - 0x03 -> 9 veces - -Offset 0x02D00 (11520): - Valores distintos (7): 0x00, 0x01, 0x04, 0x07, 0x13, 0x14, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 90 veces - 0x16 -> 37 veces - 0x13 -> 36 veces - 0x14 -> 29 veces - 0x07 -> 21 veces - -Offset 0x02D01 (11521): - Valores distintos (7): 0x00, 0x02, 0x03, 0x04, 0x0D, 0x14, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 83 veces - 0x16 -> 65 veces - 0x14 -> 41 veces - 0x03 -> 28 veces - 0x0D -> 8 veces - -Offset 0x02D02 (11522): - Valores distintos (6): 0x00, 0x02, 0x05, 0x14, 0x15, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 83 veces - 0x05 -> 65 veces - 0x14 -> 37 veces - 0x15 -> 27 veces - 0x16 -> 21 veces - -Offset 0x02D03 (11523): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0x14 - Clasificación: small_state - Más frecuentes: - 0x14 -> 92 veces - 0x00 -> 83 veces - 0x01 -> 21 veces - 0x04 -> 21 veces - 0x02 -> 17 veces - -Offset 0x02D04 (11524): - Valores distintos (7): 0x00, 0x01, 0x02, 0x0A, 0x0B, 0x11, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 98 veces - 0x0B -> 57 veces - 0x11 -> 27 veces - 0x01 -> 23 veces - 0x14 -> 21 veces - -Offset 0x02D05 (11525): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 108 veces - 0x00 -> 105 veces - 0x02 -> 21 veces - -Offset 0x02D06 (11526): - Valores distintos (3): 0x00, 0x01, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 114 veces - 0x01 -> 93 veces - 0x07 -> 27 veces - -Offset 0x02D07 (11527): - Valores distintos (5): 0x00, 0x01, 0x11, 0x13, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 124 veces - 0x14 -> 64 veces - 0x01 -> 21 veces - 0x13 -> 14 veces - 0x11 -> 11 veces - -Offset 0x02D08 (11528): - Valores distintos (4): 0x00, 0x08, 0x09, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 145 veces - 0x09 -> 41 veces - 0x16 -> 27 veces - 0x08 -> 21 veces - -Offset 0x02D09 (11529): - Valores distintos (4): 0x00, 0x01, 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 150 veces - 0x01 -> 54 veces - 0x05 -> 27 veces - 0x02 -> 3 veces - -Offset 0x02D0A (11530): - Valores distintos (3): 0x00, 0x01, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 150 veces - 0x01 -> 57 veces - 0x14 -> 27 veces - -Offset 0x02D0B (11531): - Valores distintos (3): 0x00, 0x01, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x01 -> 55 veces - 0x0B -> 27 veces - -Offset 0x02D0C (11532): - Valores distintos (3): 0x00, 0x01, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 152 veces - 0x01 -> 55 veces - 0x11 -> 27 veces - -Offset 0x02D0D (11533): - Valores distintos (3): 0x00, 0x01, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 188 veces - 0x09 -> 27 veces - 0x01 -> 19 veces - -Offset 0x02D0E (11534): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0x01 -> 41 veces - 0x02 -> 2 veces - -Offset 0x02D0F (11535): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 191 veces - 0x01 -> 43 veces - -Offset 0x02D10 (11536): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 194 veces - 0x01 -> 40 veces - -Offset 0x02D11 (11537): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 194 veces - 0x01 -> 40 veces - -Offset 0x02D12 (11538): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 199 veces - 0x01 -> 35 veces - -Offset 0x02D13 (11539): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 201 veces - 0x01 -> 33 veces - -Offset 0x02D14 (11540): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 209 veces - 0x01 -> 25 veces - -Offset 0x02D15 (11541): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 209 veces - 0x01 -> 25 veces - -Offset 0x02D16 (11542): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x02 -> 13 veces - 0x01 -> 12 veces - -Offset 0x02D17 (11543): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x02 -> 17 veces - 0x01 -> 8 veces - -Offset 0x02D18 (11544): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 216 veces - 0x01 -> 18 veces - -Offset 0x02D74 (11636): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 219 veces - 0x00 -> 15 veces - -Offset 0x02D75 (11637): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 192 veces - 0x00 -> 42 veces - -Offset 0x02D76 (11638): - Valores distintos (3): 0x00, 0x04, 0x0E - Clasificación: small_state - Más frecuentes: - 0x04 -> 137 veces - 0x00 -> 76 veces - 0x0E -> 21 veces - -Offset 0x02D77 (11639): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 147 veces - 0x00 -> 87 veces - -Offset 0x02D78 (11640): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x05 -> 142 veces - 0x00 -> 92 veces - -Offset 0x02D79 (11641): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 132 veces - 0x09 -> 102 veces - -Offset 0x02D7A (11642): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 148 veces - 0x0A -> 86 veces - -Offset 0x02D7B (11643): - Valores distintos (2): 0x00, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 153 veces - 0x06 -> 81 veces - -Offset 0x02D7C (11644): - Valores distintos (2): 0x00, 0x0D - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x0D -> 33 veces - -Offset 0x02D7D (11645): - Valores distintos (2): 0x00, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0x0C -> 20 veces - -Offset 0x02D94 (11668): - Valores distintos (3): 0x00, 0x3E, 0x45 - Clasificación: small_state - Más frecuentes: - 0x00 -> 122 veces - 0x45 -> 89 veces - 0x3E -> 23 veces - -Offset 0x02D95 (11669): - Valores distintos (2): 0x00, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 211 veces - 0x14 -> 23 veces - -Offset 0x02D96 (11670): - Valores distintos (2): 0x00, 0xAA - Clasificación: small_state - Más frecuentes: - 0x00 -> 211 veces - 0xAA -> 23 veces - -Offset 0x02D97 (11671): - Valores distintos (2): 0x00, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 211 veces - 0x0F -> 23 veces - -Offset 0x02D98 (11672): - Valores distintos (2): 0x00, 0xA3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 211 veces - 0xA3 -> 23 veces - -Offset 0x02D99 (11673): - Valores distintos (2): 0x00, 0xC4 - Clasificación: small_state - Más frecuentes: - 0x00 -> 211 veces - 0xC4 -> 23 veces - -Offset 0x02D9A (11674): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 211 veces - 0x0A -> 23 veces - -Offset 0x02D9B (11675): - Valores distintos (2): 0x00, 0xA4 - Clasificación: small_state - Más frecuentes: - 0x00 -> 211 veces - 0xA4 -> 23 veces - -Offset 0x02D9C (11676): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x00 -> 215 veces - 0x10 -> 19 veces - -Offset 0x02D9D (11677): - Valores distintos (2): 0x00, 0xA1 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0xA1 -> 5 veces - -Offset 0x02D9E (11678): - Valores distintos (2): 0x00, 0xA2 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0xA2 -> 5 veces - -Offset 0x02D9F (11679): - Valores distintos (2): 0x00, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0x3D -> 5 veces - -Offset 0x02DA0 (11680): - Valores distintos (2): 0x00, 0x0E - Clasificación: small_state - Más frecuentes: - 0x00 -> 230 veces - 0x0E -> 4 veces - -Offset 0x02DA1 (11681): - Valores distintos (2): 0x00, 0xA8 - Clasificación: small_state - Más frecuentes: - 0x00 -> 230 veces - 0xA8 -> 4 veces - -Offset 0x02E14 (11796): - Valores distintos (8): 0x00, 0x01, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 - Clasificación: small_state - Más frecuentes: - 0x06 -> 97 veces - 0x01 -> 63 veces - 0x08 -> 38 veces - 0x05 -> 19 veces - 0x00 -> 12 veces - -Offset 0x02E1A (11802): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 109 veces - 0x02 -> 65 veces - 0x01 -> 60 veces - -Offset 0x02E1B (11803): - Valores distintos (2): 0x00, 0x1E - Clasificación: small_state - Más frecuentes: - 0x1E -> 162 veces - 0x00 -> 72 veces - -Offset 0x02E1C (11804): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x02 -> 42 veces - 0x03 -> 40 veces - 0x01 -> 1 veces - -Offset 0x02E1D (11805): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0x03 -> 5 veces - -Offset 0x02E1E (11806): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 180 veces - 0x02 -> 22 veces - 0x05 -> 9 veces - 0x03 -> 9 veces - 0x04 -> 7 veces - -Offset 0x02E1F (11807): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 145 veces - 0x02 -> 74 veces - 0x01 -> 14 veces - 0x03 -> 1 veces - -Offset 0x02E20 (11808): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0x03 -> 1 veces - -Offset 0x02E21 (11809): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 188 veces - 0x03 -> 32 veces - 0x02 -> 7 veces - 0x01 -> 6 veces - 0x06 -> 1 veces - -Offset 0x02E22 (11810): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 165 veces - 0x02 -> 37 veces - 0x03 -> 19 veces - 0x01 -> 13 veces - -Offset 0x02E23 (11811): - Valores distintos (3): 0x00, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 202 veces - 0x02 -> 31 veces - 0x03 -> 1 veces - -Offset 0x02E24 (11812): - Valores distintos (9): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 162 veces - 0x03 -> 15 veces - 0x06 -> 14 veces - 0x07 -> 12 veces - 0x04 -> 11 veces - -Offset 0x02E26 (11814): - Valores distintos (6): 0x00, 0x03, 0x06, 0x0A, 0x0E, 0x1C - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x1C -> 48 veces - 0x03 -> 28 veces - 0x0A -> 22 veces - 0x0E -> 6 veces - -Offset 0x02E27 (11815): - Valores distintos (9): 0x00, 0x01, 0x03, 0x04, 0x05, 0x0C, 0x0D, 0x14, 0x20 - Clasificación: bitfield_like - Más frecuentes: - 0x03 -> 56 veces - 0x20 -> 48 veces - 0x00 -> 47 veces - 0x05 -> 25 veces - 0x04 -> 23 veces - -Offset 0x02E28 (11816): - Valores distintos (7): 0x00, 0x01, 0x02, 0x05, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 61 veces - 0x00 -> 52 veces - 0x11 -> 47 veces - 0xFF -> 42 veces - 0x09 -> 19 veces - -Offset 0x02E29 (11817): - Valores distintos (6): 0x05, 0x06, 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 86 veces - 0x0A -> 70 veces - 0x09 -> 35 veces - 0x0E -> 31 veces - 0x06 -> 9 veces - -Offset 0x02E2A (11818): - Valores distintos (6): 0x04, 0x05, 0x06, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 125 veces - 0x0A -> 44 veces - 0x04 -> 31 veces - 0x05 -> 19 veces - 0x06 -> 12 veces - -Offset 0x02E2B (11819): - Valores distintos (9): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0x62, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x41 -> 61 veces - 0xFF -> 42 veces - 0x04 -> 31 veces - 0x20 -> 28 veces - 0x02 -> 27 veces - -Offset 0x02E2C (11820): - Valores distintos (7): 0x00, 0x01, 0x02, 0x05, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 67 veces - 0x01 -> 54 veces - 0xFF -> 42 veces - 0x11 -> 35 veces - 0x02 -> 29 veces - -Offset 0x02E2D (11821): - Valores distintos (5): 0x05, 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 88 veces - 0xFF -> 63 veces - 0x09 -> 28 veces - 0x0E -> 28 veces - 0x05 -> 27 veces - -Offset 0x02E2E (11822): - Valores distintos (6): 0x04, 0x05, 0x06, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 147 veces - 0x0A -> 28 veces - 0x04 -> 28 veces - 0x09 -> 27 veces - 0x05 -> 3 veces - -Offset 0x02E2F (11823): - Valores distintos (9): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0x62, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 56 veces - 0x41 -> 54 veces - 0xFF -> 42 veces - 0x04 -> 28 veces - 0x62 -> 27 veces - -Offset 0x02E30 (11824): - Valores distintos (7): 0x00, 0x01, 0x02, 0x05, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 55 veces - 0xFF -> 52 veces - 0x00 -> 50 veces - 0x11 -> 37 veces - 0x09 -> 27 veces - -Offset 0x02E31 (11825): - Valores distintos (6): 0x05, 0x06, 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 99 veces - 0xFF -> 94 veces - 0x0E -> 21 veces - 0x05 -> 9 veces - 0x06 -> 8 veces - -Offset 0x02E32 (11826): - Valores distintos (6): 0x04, 0x05, 0x06, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 164 veces - 0x05 -> 27 veces - 0x04 -> 21 veces - 0x0A -> 11 veces - 0x09 -> 9 veces - -Offset 0x02E33 (11827): - Valores distintos (9): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0x62, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x41 -> 55 veces - 0xFF -> 52 veces - 0x02 -> 28 veces - 0x20 -> 25 veces - 0x21 -> 25 veces - -Offset 0x02E34 (11828): - Valores distintos (7): 0x00, 0x01, 0x02, 0x05, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 75 veces - 0x00 -> 53 veces - 0xFF -> 52 veces - 0x11 -> 37 veces - 0x09 -> 9 veces - -Offset 0x02E35 (11829): - Valores distintos (5): 0x06, 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 99 veces - 0x0A -> 85 veces - 0x09 -> 27 veces - 0x0E -> 22 veces - 0x06 -> 1 veces - -Offset 0x02E36 (11830): - Valores distintos (5): 0x04, 0x05, 0x06, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 173 veces - 0x0A -> 28 veces - 0x04 -> 22 veces - 0x05 -> 9 veces - 0x06 -> 2 veces - -Offset 0x02E37 (11831): - Valores distintos (8): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 75 veces - 0xFF -> 52 veces - 0x20 -> 31 veces - 0x21 -> 22 veces - 0x04 -> 22 veces - -Offset 0x02E38 (11832): - Valores distintos (6): 0x00, 0x01, 0x02, 0x05, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 86 veces - 0xFF -> 70 veces - 0x11 -> 34 veces - 0x00 -> 33 veces - 0x02 -> 9 veces - -Offset 0x02E39 (11833): - Valores distintos (4): 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 108 veces - 0xFF -> 94 veces - 0x0E -> 20 veces - 0x09 -> 12 veces - -Offset 0x02E3A (11834): - Valores distintos (4): 0x04, 0x06, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 199 veces - 0x04 -> 20 veces - 0x0A -> 12 veces - 0x06 -> 3 veces - -Offset 0x02E3B (11835): - Valores distintos (8): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 86 veces - 0xFF -> 70 veces - 0x21 -> 24 veces - 0x04 -> 20 veces - 0x08 -> 14 veces - -Offset 0x02E3C (11836): - Valores distintos (6): 0x00, 0x01, 0x02, 0x05, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 86 veces - 0xFF -> 71 veces - 0x00 -> 38 veces - 0x11 -> 31 veces - 0x05 -> 5 veces - -Offset 0x02E3D (11837): - Valores distintos (5): 0x05, 0x06, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 106 veces - 0x0A -> 103 veces - 0x0E -> 21 veces - 0x05 -> 3 veces - 0x06 -> 1 veces - -Offset 0x02E3E (11838): - Valores distintos (5): 0x04, 0x06, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 203 veces - 0x04 -> 21 veces - 0x06 -> 6 veces - 0x09 -> 3 veces - 0x0A -> 1 veces - -Offset 0x02E3F (11839): - Valores distintos (8): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 86 veces - 0xFF -> 71 veces - 0x20 -> 21 veces - 0x04 -> 21 veces - 0x21 -> 17 veces - -Offset 0x02E40 (11840): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 163 veces - 0xFF -> 71 veces - -Offset 0x02E41 (11841): - Valores distintos (2): 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 163 veces - 0xFF -> 71 veces - -Offset 0x02E43 (11843): - Valores distintos (2): 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 163 veces - 0xFF -> 71 veces - -Offset 0x02E44 (11844): - Valores distintos (2): 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 196 veces - 0x11 -> 38 veces - -Offset 0x02E45 (11845): - Valores distintos (2): 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 196 veces - 0x0E -> 38 veces - -Offset 0x02E46 (11846): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 196 veces - 0x04 -> 38 veces - -Offset 0x02E47 (11847): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 196 veces - 0x04 -> 38 veces - -Offset 0x02E70 (11888): - Valores distintos (8): 0x00, 0x41, 0x43, 0x47, 0xC7, 0xCF, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 73 veces - 0xEF -> 48 veces - 0x00 -> 42 veces - 0x41 -> 30 veces - 0xCF -> 15 veces - -Offset 0x02E71 (11889): - Valores distintos (9): 0x00, 0x08, 0x0C, 0x0D, 0x0F, 0x2F, 0x3F, 0xBF, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xFF -> 59 veces - 0x0C -> 46 veces - 0x00 -> 43 veces - 0x0D -> 34 veces - 0x3F -> 21 veces - -Offset 0x02E72 (11890): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 98 veces - 0x01 -> 76 veces - 0x03 -> 60 veces - -Offset 0x02E74 (11892): - Valores distintos (9): 0x00, 0x02, 0x03, 0x23, 0x27, 0x37, 0x77, 0xF7, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xFF -> 129 veces - 0x03 -> 22 veces - 0x27 -> 20 veces - 0x77 -> 15 veces - 0x00 -> 13 veces - -Offset 0x02E75 (11893): - Valores distintos (8): 0x00, 0x01, 0x03, 0x07, 0x1F, 0x5F, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 98 veces - 0xFF -> 59 veces - 0x01 -> 33 veces - 0x07 -> 13 veces - 0x1F -> 10 veces - -Offset 0x02E76 (11894): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 120 veces - 0x01 -> 114 veces - -Offset 0x02E77 (11895): - Valores distintos (9): 0x00, 0x02, 0x03, 0x23, 0x27, 0x37, 0xB7, 0xBF, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xBF -> 90 veces - 0xFF -> 39 veces - 0x37 -> 23 veces - 0x03 -> 22 veces - 0x27 -> 20 veces - -Offset 0x02E78 (11896): - Valores distintos (9): 0x00, 0x01, 0x03, 0x0B, 0x4B, 0x6B, 0xEB, 0xFB, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 98 veces - 0x01 -> 43 veces - 0xFF -> 37 veces - 0xFB -> 15 veces - 0x0B -> 10 veces - -Offset 0x02E79 (11897): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 199 veces - 0x01 -> 35 veces - -Offset 0x02EA5 (11941): - Valores distintos (11): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0B - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 124 veces - 0x00 -> 71 veces - 0x01 -> 8 veces - 0x09 -> 5 veces - 0x04 -> 5 veces - -Offset 0x02EA6 (11942): - Valores distintos (11): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x0B -> 57 veces - 0x05 -> 41 veces - 0x02 -> 38 veces - 0xFF -> 27 veces - 0x00 -> 18 veces - -Offset 0x02EA7 (11943): - Valores distintos (11): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x05 -> 80 veces - 0xFF -> 44 veces - 0x08 -> 40 veces - 0x01 -> 18 veces - 0x02 -> 15 veces - -Offset 0x02EA8 (11944): - Valores distintos (43): 0x01, 0x03, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x26, 0x27, 0x28, 0x2A, 0x2B, 0x2C, 0x2E, 0x31, 0x32, 0x33, 0x34 - Clasificación: bitfield_like - Más frecuentes: - 0x34 -> 16 veces - 0x19 -> 13 veces - 0x1E -> 13 veces - 0x15 -> 11 veces - 0x11 -> 10 veces - -Offset 0x02EAC (11948): - Valores distintos (62): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x30, 0x31, 0x32, 0x33, 0x35, 0x36, 0x37, 0x38, 0x3B, 0x3D, 0x3F, 0x41, 0x43, 0x44, 0x45, 0x46, 0x47 - Clasificación: bitfield_like - Más frecuentes: - 0x06 -> 14 veces - 0x19 -> 9 veces - 0x05 -> 8 veces - 0x0C -> 8 veces - 0x29 -> 8 veces - -Offset 0x02EAD (11949): - Valores distintos (56): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A - Clasificación: bitfield_like - Más frecuentes: - 0x08 -> 13 veces - 0x06 -> 12 veces - 0x1A -> 10 veces - 0x02 -> 8 veces - 0x38 -> 7 veces - -Offset 0x02EAE (11950): - Valores distintos (55): 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2F, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B - Clasificación: bitfield_like - Más frecuentes: - 0x35 -> 12 veces - 0x18 -> 10 veces - 0x03 -> 9 veces - 0x10 -> 9 veces - 0x27 -> 9 veces - -Offset 0x02EAF (11951): - Valores distintos (30): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D - Clasificación: bitfield_like - Más frecuentes: - 0x18 -> 16 veces - 0x0C -> 16 veces - 0x1C -> 14 veces - 0x03 -> 14 veces - 0x1D -> 13 veces - -Offset 0x02EB0 (11952): - Valores distintos (113): 0x00, 0x03, 0x05, 0x08, 0x0A, 0x0B, 0x0D, 0x10, 0x12, 0x13, 0x16, 0x18, 0x19, 0x1C, 0x1F, 0x22, 0x23, 0x24, 0x26, 0x27, 0x29, 0x2A, 0x2C, 0x2F, 0x31, 0x32, 0x34, 0x38, 0x3C, 0x3D, 0x3E, 0x45, 0x47, 0x4A, 0x50, 0x52, 0x53, 0x54, 0x57, 0x59, 0x5E, 0x62, 0x63, 0x65, 0x66, 0x68, 0x6A, 0x6C, 0x6E, 0x75, 0x7A, 0x7F, 0x80, 0x81, 0x83, 0x86, 0x87, 0x88, 0x8B, 0x8C, 0x8F, 0x90, 0x93, 0x94, 0x96, 0x98, 0x99, 0x9A, 0x9D, 0xA1, 0xA3, 0xA4, 0xA7, 0xA8, 0xA9, 0xAC, 0xB0, 0xB3, 0xB4, 0xB8, 0xB9, 0xBA, 0xBE, 0xBF, 0xC0, 0xC2, 0xC3, 0xC6, 0xC9, 0xCA, 0xCC, 0xCE, 0xD2, 0xD5, 0xD7, 0xD8, 0xDC, 0xE1, 0xE2, 0xE6, 0xEA, 0xEB, 0xEC, 0xF0, 0xF1, 0xF3, 0xF7, 0xF8, 0xF9, 0xFB, 0xFC, 0xFD, 0xFE - Clasificación: bitfield_like - Más frecuentes: - 0xB9 -> 10 veces - 0x2F -> 8 veces - 0x22 -> 7 veces - 0xFE -> 6 veces - 0xC3 -> 6 veces - -Offset 0x02EB1 (11953): - Valores distintos (100): 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0C, 0x0E, 0x0F, 0x12, 0x13, 0x16, 0x17, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x22, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x3A, 0x3C, 0x3F, 0x41, 0x42, 0x44, 0x45, 0x4B, 0x4C, 0x4D, 0x4E, 0x51, 0x55, 0x57, 0x59, 0x5A, 0x5B, 0x5C, 0x60, 0x61, 0x62, 0x66, 0x6C, 0x71, 0x74, 0x79, 0x7B, 0x7E, 0x82, 0x83, 0x85, 0x86, 0x88, 0x8D, 0x8F, 0x93, 0x99, 0x9B, 0x9F, 0xA3, 0xA4, 0xA5, 0xA7, 0xAF, 0xB1, 0xB2, 0xB4, 0xB5, 0xBA, 0xBD, 0xC1, 0xC2, 0xC7, 0xCD, 0xD2, 0xD3, 0xDE, 0xE0, 0xE4, 0xF1, 0xF4, 0xF6, 0xFA - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 13 veces - 0x32 -> 12 veces - 0x66 -> 10 veces - 0xA7 -> 7 veces - 0xCD -> 7 veces - -Offset 0x02EB2 (11954): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0A - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 159 veces - 0x01 -> 31 veces - 0x0A -> 19 veces - 0x02 -> 9 veces - 0x09 -> 5 veces - -Offset 0x02EB4 (11956): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 224 veces - 0x01 -> 10 veces - -Offset 0x02ED0 (11984): - Valores distintos (11): 0x00, 0x02, 0x05, 0x06, 0x07, 0x09, 0x0F, 0x17, 0x1C, 0x21, 0x23 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 196 veces - 0x09 -> 16 veces - 0x21 -> 7 veces - 0x05 -> 3 veces - 0x06 -> 3 veces - -Offset 0x02ED4 (11988): - Valores distintos (7): 0x00, 0x38, 0x58, 0x85, 0xAD, 0xD3, 0xFA - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x85 -> 85 veces - 0x58 -> 9 veces - 0xFA -> 8 veces - 0xD3 -> 7 veces - -Offset 0x02ED5 (11989): - Valores distintos (3): 0x00, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x03 -> 99 veces - 0x02 -> 19 veces - -Offset 0x02ED8 (11992): - Valores distintos (24): 0x00, 0x05, 0x12, 0x1A, 0x21, 0x24, 0x44, 0x47, 0x58, 0x66, 0x68, 0x71, 0x8D, 0x92, 0x9C, 0xAB, 0xAD, 0xB3, 0xBF, 0xCC, 0xD0, 0xD1, 0xD4, 0xE6 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 116 veces - 0xD1 -> 15 veces - 0xD4 -> 10 veces - 0x44 -> 9 veces - 0xE6 -> 8 veces - -Offset 0x02ED9 (11993): - Valores distintos (7): 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x03 -> 34 veces - 0x04 -> 30 veces - 0x02 -> 19 veces - 0x06 -> 15 veces - -Offset 0x02EDC (11996): - Valores distintos (24): 0x00, 0x19, 0x26, 0x2E, 0x35, 0x38, 0x58, 0x5B, 0x6C, 0x7A, 0x7C, 0x85, 0xA1, 0xA6, 0xAD, 0xB0, 0xBF, 0xC7, 0xD3, 0xE0, 0xE4, 0xE5, 0xE8, 0xFA - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 116 veces - 0xE5 -> 15 veces - 0xE8 -> 10 veces - 0x58 -> 9 veces - 0xFA -> 8 veces - -Offset 0x02EDD (11997): - Valores distintos (7): 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x03 -> 34 veces - 0x04 -> 30 veces - 0x02 -> 19 veces - 0x06 -> 15 veces - -Offset 0x02EE0 (12000): - Valores distintos (27): 0x00, 0x10, 0x11, 0x14, 0x33, 0x38, 0x45, 0x51, 0x55, 0x58, 0x59, 0x5A, 0x5C, 0x5D, 0x5E, 0x70, 0xAD, 0xB4, 0xBC, 0xC9, 0xD9, 0xDA, 0xDC, 0xE3, 0xE8, 0xF4, 0xF7 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 116 veces - 0x70 -> 58 veces - 0x58 -> 10 veces - 0x5C -> 10 veces - 0x5A -> 7 veces - -Offset 0x02EE1 (12001): - Valores distintos (3): 0x00, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x03 -> 107 veces - 0x02 -> 11 veces - -Offset 0x02EE4 (12004): - Valores distintos (28): 0x00, 0x10, 0x11, 0x14, 0x33, 0x38, 0x45, 0x51, 0x55, 0x58, 0x76, 0x85, 0x8F, 0xA3, 0xAD, 0xB4, 0xB7, 0xBC, 0xC1, 0xC9, 0xCB, 0xD9, 0xDA, 0xDC, 0xE3, 0xE8, 0xF4, 0xF7 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 116 veces - 0xE3 -> 53 veces - 0xA3 -> 10 veces - 0x76 -> 7 veces - 0x8F -> 7 veces - -Offset 0x02EE5 (12005): - Valores distintos (3): 0x00, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x03 -> 107 veces - 0x02 -> 11 veces - -Offset 0x02EE8 (12008): - Valores distintos (8): 0x00, 0xAF, 0xB0, 0xB2, 0xB4, 0xB5, 0xB6, 0xB9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0xB9 -> 40 veces - 0xB5 -> 32 veces - 0xB4 -> 19 veces - 0xB0 -> 15 veces - -Offset 0x02EEA (12010): - Valores distintos (4): 0x00, 0x0A, 0x42, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x63 -> 107 veces - 0x42 -> 7 veces - 0x0A -> 4 veces - -Offset 0x02EEB (12011): - Valores distintos (9): 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0A - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 116 veces - 0x0A -> 52 veces - 0x01 -> 36 veces - 0x04 -> 10 veces - 0x02 -> 7 veces - -Offset 0x02EEC (12012): - Valores distintos (7): 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x07 -> 58 veces - 0x04 -> 10 veces - 0x02 -> 7 veces - 0x06 -> 4 veces - -Offset 0x02EED (12013): - Valores distintos (7): 0x00, 0x02, 0x05, 0x09, 0x0C, 0x0F, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 192 veces - 0x05 -> 20 veces - 0x0C -> 9 veces - 0x02 -> 4 veces - 0x09 -> 3 veces - -Offset 0x02EEE (12014): - Valores distintos (8): 0x00, 0x03, 0x04, 0x08, 0x09, 0x0B, 0x0F, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 193 veces - 0x0F -> 9 veces - 0x03 -> 8 veces - 0x09 -> 7 veces - 0x04 -> 5 veces - -Offset 0x02EF8 (12024): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 135 veces - 0x01 -> 99 veces - -Offset 0x02EF9 (12025): - Valores distintos (5): 0x00, 0x01, 0x04, 0x09, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x04 -> 50 veces - 0x01 -> 36 veces - 0x0B -> 8 veces - 0x09 -> 5 veces - -Offset 0x02EFC (12028): - Valores distintos (7): 0x00, 0x26, 0x35, 0x38, 0x58, 0x5B, 0xC7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x58 -> 36 veces - 0x26 -> 30 veces - 0x5B -> 20 veces - 0x38 -> 5 veces - -Offset 0x02EFD (12029): - Valores distintos (5): 0x00, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x03 -> 41 veces - 0x05 -> 30 veces - 0x04 -> 23 veces - 0x07 -> 5 veces - -Offset 0x02F38 (12088): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 149 veces - 0x01 -> 85 veces - -Offset 0x02F39 (12089): - Valores distintos (3): 0x00, 0x02, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x02 -> 45 veces - 0x06 -> 40 veces - -Offset 0x02F3C (12092): - Valores distintos (4): 0x00, 0x7C, 0x85, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0xE0 -> 40 veces - 0x85 -> 33 veces - 0x7C -> 12 veces - -Offset 0x02F3D (12093): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x04 -> 52 veces - 0x03 -> 33 veces - -Offset 0x02F48 (12104): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 127 veces - 0x01 -> 107 veces - -Offset 0x02F49 (12105): - Valores distintos (5): 0x00, 0x03, 0x07, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x07 -> 40 veces - 0x03 -> 27 veces - 0x0B -> 25 veces - 0x0A -> 15 veces - -Offset 0x02F4C (12108): - Valores distintos (10): 0x00, 0x35, 0x58, 0x5B, 0x7C, 0x85, 0xA6, 0xBF, 0xE0, 0xFA - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 127 veces - 0xE0 -> 40 veces - 0x85 -> 27 veces - 0xFA -> 13 veces - 0x58 -> 9 veces - -Offset 0x02F4D (12109): - Valores distintos (4): 0x00, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x04 -> 58 veces - 0x03 -> 36 veces - 0x02 -> 13 veces - -Offset 0x02F88 (12168): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 135 veces - 0x01 -> 99 veces - -Offset 0x02F89 (12169): - Valores distintos (3): 0x00, 0x02, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x02 -> 85 veces - 0x09 -> 14 veces - -Offset 0x02F8C (12172): - Valores distintos (4): 0x00, 0x38, 0x7C, 0x85 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x7C -> 52 veces - 0x85 -> 33 veces - 0x38 -> 14 veces - -Offset 0x02F8D (12173): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x04 -> 52 veces - 0x03 -> 47 veces - -Offset 0x02FA8 (12200): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 135 veces - 0x01 -> 99 veces - -Offset 0x02FA9 (12201): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x09 -> 99 veces - -Offset 0x02FAC (12204): - Valores distintos (2): 0x00, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x38 -> 99 veces - -Offset 0x02FAD (12205): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x03 -> 99 veces - -Offset 0x02FB0 (12208): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 135 veces - 0x01 -> 99 veces - -Offset 0x02FB1 (12209): - Valores distintos (4): 0x00, 0x02, 0x03, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x03 -> 55 veces - 0x02 -> 30 veces - 0x09 -> 14 veces - -Offset 0x02FB4 (12212): - Valores distintos (4): 0x00, 0x38, 0x5B, 0x85 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x5B -> 55 veces - 0x85 -> 30 veces - 0x38 -> 14 veces - -Offset 0x02FB5 (12213): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x04 -> 55 veces - 0x03 -> 44 veces - -Offset 0x02FB8 (12216): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 140 veces - 0x01 -> 94 veces - -Offset 0x02FB9 (12217): - Valores distintos (5): 0x00, 0x04, 0x08, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x08 -> 40 veces - 0x0B -> 23 veces - 0x0A -> 18 veces - 0x04 -> 13 veces - -Offset 0x02FBA (12218): - Valores distintos (2): 0x00, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0x28 -> 5 veces - -Offset 0x02FBB (12219): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0x10 -> 5 veces - -Offset 0x02FBC (12220): - Valores distintos (14): 0x00, 0x26, 0x2E, 0x58, 0x5B, 0x7A, 0x7C, 0xA6, 0xB0, 0xBF, 0xC7, 0xCE, 0xE0, 0xE5 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 140 veces - 0xE5 -> 15 veces - 0xCE -> 13 veces - 0x58 -> 12 veces - 0x26 -> 10 veces - -Offset 0x02FBD (12221): - Valores distintos (6): 0x00, 0x03, 0x04, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x03 -> 32 veces - 0x04 -> 27 veces - 0x06 -> 15 veces - 0x05 -> 10 veces - -Offset 0x02FC0 (12224): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 120 veces - 0x01 -> 114 veces - -Offset 0x02FC1 (12225): - Valores distintos (6): 0x00, 0x03, 0x07, 0x09, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x07 -> 35 veces - 0x09 -> 29 veces - 0x03 -> 27 veces - 0x0B -> 17 veces - -Offset 0x02FC4 (12228): - Valores distintos (9): 0x00, 0x26, 0x35, 0x5B, 0x7C, 0x85, 0xA6, 0xBF, 0xD3 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 120 veces - 0x26 -> 35 veces - 0xD3 -> 29 veces - 0x85 -> 27 veces - 0xBF -> 8 veces - -Offset 0x02FC5 (12229): - Valores distintos (5): 0x00, 0x02, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x05 -> 35 veces - 0x02 -> 29 veces - 0x03 -> 27 veces - 0x04 -> 23 veces - -Offset 0x02FC8 (12232): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 118 veces - 0x00 -> 116 veces - -Offset 0x02FC9 (12233): - Valores distintos (3): 0x00, 0x04, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x09 -> 113 veces - 0x04 -> 5 veces - -Offset 0x02FCC (12236): - Valores distintos (3): 0x00, 0xAD, 0xC7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0xAD -> 113 veces - 0xC7 -> 5 veces - -Offset 0x02FCD (12237): - Valores distintos (3): 0x00, 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x02 -> 113 veces - 0x07 -> 5 veces - -Offset 0x03000 (12288): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 135 veces - 0x01 -> 99 veces - -Offset 0x03001 (12289): - Valores distintos (5): 0x00, 0x01, 0x03, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x01 -> 58 veces - 0x03 -> 27 veces - 0x0A -> 9 veces - 0x0B -> 5 veces - -Offset 0x03004 (12292): - Valores distintos (5): 0x00, 0x35, 0x38, 0x58, 0x85 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x35 -> 58 veces - 0x85 -> 27 veces - 0x58 -> 9 veces - 0x38 -> 5 veces - -Offset 0x03005 (12293): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x04 -> 58 veces - 0x03 -> 41 veces - -Offset 0x03008 (12296): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 135 veces - 0x01 -> 99 veces - -Offset 0x03009 (12297): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x09 -> 99 veces - -Offset 0x0300C (12300): - Valores distintos (2): 0x00, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x38 -> 99 veces - -Offset 0x0300D (12301): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x03 -> 99 veces - -Offset 0x03048 (12360): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 118 veces - 0x00 -> 116 veces - -Offset 0x03049 (12361): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x09 -> 118 veces - 0x00 -> 116 veces - -Offset 0x0304C (12364): - Valores distintos (2): 0x00, 0xAD - Clasificación: small_state - Más frecuentes: - 0xAD -> 118 veces - 0x00 -> 116 veces - -Offset 0x0304D (12365): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 118 veces - 0x00 -> 116 veces - -Offset 0x03078 (12408): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 120 veces - 0x01 -> 114 veces - -Offset 0x03079 (12409): - Valores distintos (5): 0x00, 0x04, 0x06, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x0A -> 38 veces - 0x06 -> 35 veces - 0x0B -> 28 veces - 0x04 -> 13 veces - -Offset 0x0307C (12412): - Valores distintos (10): 0x00, 0x26, 0x2E, 0x5B, 0x7C, 0xA6, 0xB0, 0xBF, 0xCE, 0xD3 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 120 veces - 0x26 -> 35 veces - 0xD3 -> 32 veces - 0xCE -> 13 veces - 0xBF -> 8 veces - -Offset 0x0307D (12413): - Valores distintos (5): 0x00, 0x02, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x05 -> 35 veces - 0x02 -> 32 veces - 0x04 -> 27 veces - 0x03 -> 20 veces - -Offset 0x03080 (12416): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 120 veces - 0x01 -> 114 veces - -Offset 0x03081 (12417): - Valores distintos (6): 0x00, 0x04, 0x05, 0x09, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x09 -> 54 veces - 0x04 -> 47 veces - 0x0B -> 7 veces - 0x05 -> 3 veces - -Offset 0x03084 (12420): - Valores distintos (8): 0x00, 0x19, 0x26, 0x2E, 0x5B, 0x7C, 0xC7, 0xD3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0xD3 -> 49 veces - 0x26 -> 30 veces - 0x7C -> 17 veces - 0x2E -> 7 veces - -Offset 0x03085 (12421): - Valores distintos (5): 0x00, 0x02, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x02 -> 49 veces - 0x04 -> 30 veces - 0x05 -> 30 veces - 0x07 -> 5 veces - -Offset 0x03088 (12424): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 127 veces - 0x01 -> 107 veces - -Offset 0x03089 (12425): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x09 -> 107 veces - -Offset 0x0308C (12428): - Valores distintos (2): 0x00, 0xFA - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0xFA -> 107 veces - -Offset 0x0308D (12429): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x02 -> 107 veces - -Offset 0x03090 (12432): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 118 veces - 0x00 -> 116 veces - -Offset 0x03091 (12433): - Valores distintos (5): 0x00, 0x03, 0x04, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x0A -> 42 veces - 0x03 -> 35 veces - 0x0B -> 28 veces - 0x04 -> 13 veces - -Offset 0x03094 (12436): - Valores distintos (10): 0x00, 0x26, 0x2E, 0x5B, 0x7C, 0xA6, 0xAD, 0xB0, 0xBF, 0xCE - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 116 veces - 0xAD -> 36 veces - 0x26 -> 35 veces - 0xCE -> 13 veces - 0xBF -> 8 veces - -Offset 0x03095 (12437): - Valores distintos (5): 0x00, 0x02, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 116 veces - 0x02 -> 36 veces - 0x05 -> 35 veces - 0x04 -> 27 veces - 0x03 -> 20 veces - -Offset 0x03098 (12440): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 140 veces - 0x01 -> 94 veces - -Offset 0x03099 (12441): - Valores distintos (3): 0x00, 0x01, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x05 -> 58 veces - 0x01 -> 36 veces - -Offset 0x0309C (12444): - Valores distintos (3): 0x00, 0x35, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x35 -> 58 veces - 0x58 -> 36 veces - -Offset 0x0309D (12445): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x04 -> 58 veces - 0x03 -> 36 veces - -Offset 0x030A0 (12448): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 149 veces - 0x01 -> 85 veces - -Offset 0x030A1 (12449): - Valores distintos (5): 0x00, 0x02, 0x05, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x02 -> 35 veces - 0x0B -> 28 veces - 0x05 -> 13 veces - 0x0A -> 9 veces - -Offset 0x030A4 (12452): - Valores distintos (10): 0x00, 0x26, 0x2E, 0x5B, 0x7C, 0x85, 0xA6, 0xB0, 0xBF, 0xCE - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 149 veces - 0x26 -> 35 veces - 0xCE -> 13 veces - 0xBF -> 8 veces - 0xB0 -> 7 veces - -Offset 0x030A5 (12453): - Valores distintos (4): 0x00, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x05 -> 35 veces - 0x04 -> 27 veces - 0x03 -> 23 veces - -Offset 0x030A8 (12456): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 127 veces - 0x01 -> 107 veces - -Offset 0x030A9 (12457): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x09 -> 107 veces - -Offset 0x030AC (12460): - Valores distintos (2): 0x00, 0xFA - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0xFA -> 107 veces - -Offset 0x030AD (12461): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x02 -> 107 veces - -Offset 0x030B0 (12464): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 140 veces - 0x01 -> 94 veces - -Offset 0x030B1 (12465): - Valores distintos (5): 0x00, 0x01, 0x04, 0x09, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x04 -> 50 veces - 0x01 -> 36 veces - 0x09 -> 5 veces - 0x0B -> 3 veces - -Offset 0x030B4 (12468): - Valores distintos (6): 0x00, 0x26, 0x35, 0x58, 0x5B, 0xC7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x58 -> 36 veces - 0x26 -> 30 veces - 0x5B -> 20 veces - 0xC7 -> 5 veces - -Offset 0x030B5 (12469): - Valores distintos (5): 0x00, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x03 -> 36 veces - 0x05 -> 30 veces - 0x04 -> 23 veces - 0x07 -> 5 veces - -Offset 0x030D0 (12496): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x05 -> 58 veces - 0x04 -> 36 veces - -Offset 0x030D1 (12497): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x030D3 (12499): - Valores distintos (5): 0x00, 0x01, 0x06, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 176 veces - 0x0B -> 46 veces - 0x0A -> 6 veces - 0x01 -> 3 veces - 0x06 -> 3 veces - -Offset 0x030D4 (12500): - Valores distintos (6): 0x00, 0x35, 0x58, 0x5B, 0x7C, 0xA6 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0xA6 -> 46 veces - 0x58 -> 36 veces - 0x7C -> 6 veces - 0x35 -> 3 veces - -Offset 0x030D5 (12501): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x04 -> 58 veces - 0x03 -> 36 veces - -Offset 0x030D8 (12504): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x05 -> 52 veces - 0x04 -> 33 veces - -Offset 0x030D9 (12505): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 182 veces - 0x01 -> 52 veces - -Offset 0x030DB (12507): - Valores distintos (5): 0x00, 0x01, 0x07, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 182 veces - 0x0B -> 40 veces - 0x01 -> 6 veces - 0x07 -> 3 veces - 0x0A -> 3 veces - -Offset 0x030DC (12508): - Valores distintos (6): 0x00, 0x7C, 0x85, 0xA6, 0xBF, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0xE0 -> 40 veces - 0x85 -> 33 veces - 0x7C -> 6 veces - 0xA6 -> 3 veces - -Offset 0x030DD (12509): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x04 -> 52 veces - 0x03 -> 33 veces - -Offset 0x030E0 (12512): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x05 -> 55 veces - 0x04 -> 30 veces - -Offset 0x030E1 (12513): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x02 -> 55 veces - 0x01 -> 30 veces - -Offset 0x030E3 (12515): - Valores distintos (5): 0x00, 0x01, 0x05, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 179 veces - 0x0B -> 43 veces - 0x05 -> 6 veces - 0x01 -> 3 veces - 0x0A -> 3 veces - -Offset 0x030E4 (12516): - Valores distintos (6): 0x00, 0x5B, 0x7C, 0x85, 0xA6, 0xBF - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0xBF -> 43 veces - 0x85 -> 30 veces - 0x7C -> 6 veces - 0x5B -> 3 veces - -Offset 0x030E5 (12517): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x04 -> 55 veces - 0x03 -> 30 veces - -Offset 0x030E8 (12520): - Valores distintos (5): 0x00, 0x04, 0x0B, 0x0C, 0x0D - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0x0C -> 30 veces - 0x04 -> 20 veces - 0x0B -> 20 veces - 0x0D -> 5 veces - -Offset 0x030E9 (12521): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 214 veces - 0x01 -> 20 veces - -Offset 0x030EB (12523): - Valores distintos (5): 0x00, 0x05, 0x13, 0x1B, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 217 veces - 0x05 -> 6 veces - 0x26 -> 5 veces - 0x13 -> 3 veces - 0x1B -> 3 veces - -Offset 0x030EC (12524): - Valores distintos (9): 0x00, 0x26, 0x5B, 0x7C, 0xA6, 0xBF, 0xC7, 0xCE, 0xE0 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 159 veces - 0x26 -> 30 veces - 0xCE -> 20 veces - 0x7C -> 6 veces - 0xE0 -> 5 veces - -Offset 0x030ED (12525): - Valores distintos (5): 0x00, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0x05 -> 30 veces - 0x03 -> 20 veces - 0x04 -> 20 veces - 0x07 -> 5 veces - -Offset 0x030F0 (12528): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0x05 -> 58 veces - 0x04 -> 17 veces - -Offset 0x030F1 (12529): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 217 veces - 0x01 -> 17 veces - -Offset 0x030F2 (12530): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 176 veces - 0x01 -> 58 veces - -Offset 0x030F3 (12531): - Valores distintos (7): 0x00, 0x01, 0x03, 0x05, 0x08, 0x09, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 176 veces - 0x0B -> 40 veces - 0x05 -> 6 veces - 0x01 -> 3 veces - 0x03 -> 3 veces - -Offset 0x030F4 (12532): - Valores distintos (8): 0x00, 0x35, 0x5B, 0x7C, 0xA6, 0xBF, 0xCE, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0xE0 -> 40 veces - 0xCE -> 17 veces - 0x7C -> 6 veces - 0x35 -> 3 veces - -Offset 0x030F5 (12533): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0x04 -> 58 veces - 0x03 -> 17 veces - -Offset 0x030F8 (12536): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x05 -> 40 veces - -Offset 0x030F9 (12537): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 194 veces - 0x01 -> 40 veces - -Offset 0x030FA (12538): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 194 veces - 0x01 -> 40 veces - -Offset 0x030FB (12539): - Valores distintos (5): 0x00, 0x01, 0x05, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x0B -> 29 veces - 0x01 -> 5 veces - 0x05 -> 3 veces - 0x0A -> 3 veces - -Offset 0x030FC (12540): - Valores distintos (5): 0x00, 0x26, 0x6C, 0xA1, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0xA1 -> 29 veces - 0xE0 -> 5 veces - 0x26 -> 3 veces - 0x6C -> 3 veces - -Offset 0x030FD (12541): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x05 -> 35 veces - 0x04 -> 5 veces - -Offset 0x03100 (12544): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x05 -> 40 veces - -Offset 0x03101 (12545): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x02 -> 40 veces - -Offset 0x03102 (12546): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 194 veces - 0x01 -> 40 veces - -Offset 0x03103 (12547): - Valores distintos (4): 0x00, 0x01, 0x06, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x0B -> 32 veces - 0x01 -> 5 veces - 0x06 -> 3 veces - -Offset 0x03104 (12548): - Valores distintos (4): 0x00, 0x26, 0x6C, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x6C -> 32 veces - 0xE0 -> 5 veces - 0x26 -> 3 veces - -Offset 0x03105 (12549): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x05 -> 35 veces - 0x04 -> 5 veces - -Offset 0x03108 (12552): - Valores distintos (3): 0x00, 0x07, 0x0D - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x07 -> 35 veces - 0x0D -> 5 veces - -Offset 0x0310C (12556): - Valores distintos (3): 0x00, 0x26, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x26 -> 35 veces - 0xE0 -> 5 veces - -Offset 0x0310D (12557): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x05 -> 35 veces - 0x04 -> 5 veces - -Offset 0x03115 (12565): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x53 -> 99 veces - -Offset 0x03116 (12566): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x65 -> 99 veces - -Offset 0x03117 (12567): - Valores distintos (2): 0x00, 0x72 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x72 -> 99 veces - -Offset 0x03118 (12568): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x6F -> 99 veces - -Offset 0x03119 (12569): - Valores distintos (2): 0x00, 0x77 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x77 -> 99 veces - -Offset 0x0313D (12605): - Valores distintos (2): 0x00, 0x50 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x50 -> 85 veces - -Offset 0x0313E (12606): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x6F -> 85 veces - -Offset 0x0313F (12607): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x6F -> 85 veces - -Offset 0x03140 (12608): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x63 -> 85 veces - -Offset 0x03141 (12609): - Valores distintos (2): 0x00, 0x68 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x68 -> 85 veces - -Offset 0x03147 (12615): - Valores distintos (2): 0x00, 0x43 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x43 -> 107 veces - -Offset 0x03148 (12616): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x6F -> 107 veces - -Offset 0x03149 (12617): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x6F -> 107 veces - -Offset 0x0314A (12618): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0xFF -> 107 veces - -Offset 0x0314B (12619): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0xFF -> 107 veces - -Offset 0x0316F (12655): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x4B -> 99 veces - -Offset 0x03170 (12656): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x61 -> 99 veces - -Offset 0x03171 (12657): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x6C -> 99 veces - -Offset 0x03172 (12658): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x65 -> 99 veces - -Offset 0x03173 (12659): - Valores distintos (2): 0x00, 0x6E - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x6E -> 99 veces - -Offset 0x03183 (12675): - Valores distintos (2): 0x00, 0x50 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x50 -> 99 veces - -Offset 0x03184 (12676): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x69 -> 99 veces - -Offset 0x03185 (12677): - Valores distintos (2): 0x00, 0x6E - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x6E -> 99 veces - -Offset 0x03186 (12678): - Valores distintos (2): 0x00, 0x6B - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x6B -> 99 veces - -Offset 0x03187 (12679): - Valores distintos (2): 0x00, 0x79 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x79 -> 99 veces - -Offset 0x03188 (12680): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x53 -> 99 veces - -Offset 0x03189 (12681): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x69 -> 99 veces - -Offset 0x0318A (12682): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x6C -> 99 veces - -Offset 0x0318B (12683): - Valores distintos (2): 0x00, 0x76 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x76 -> 99 veces - -Offset 0x0318C (12684): - Valores distintos (2): 0x00, 0x79 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x79 -> 99 veces - -Offset 0x0318D (12685): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x53 -> 94 veces - -Offset 0x0318E (12686): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x70 -> 94 veces - -Offset 0x0318F (12687): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x69 -> 94 veces - -Offset 0x03190 (12688): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x63 -> 94 veces - -Offset 0x03191 (12689): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x65 -> 94 veces - -Offset 0x03192 (12690): - Valores distintos (2): 0x00, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x4D -> 114 veces - -Offset 0x03193 (12691): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x61 -> 114 veces - -Offset 0x03194 (12692): - Valores distintos (2): 0x00, 0x72 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x72 -> 114 veces - -Offset 0x03195 (12693): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x69 -> 114 veces - -Offset 0x03196 (12694): - Valores distintos (2): 0x00, 0x6E - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x6E -> 114 veces - -Offset 0x03197 (12695): - Valores distintos (2): 0x00, 0x41 - Clasificación: small_state - Más frecuentes: - 0x41 -> 118 veces - 0x00 -> 116 veces - -Offset 0x03198 (12696): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x6C -> 118 veces - 0x00 -> 116 veces - -Offset 0x03199 (12697): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x70 -> 118 veces - 0x00 -> 116 veces - -Offset 0x0319A (12698): - Valores distintos (2): 0x00, 0x68 - Clasificación: small_state - Más frecuentes: - 0x68 -> 118 veces - 0x00 -> 116 veces - -Offset 0x0319B (12699): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x61 -> 118 veces - 0x00 -> 116 veces - -Offset 0x031BA (12730): - Valores distintos (2): 0x00, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x41 -> 99 veces - -Offset 0x031BB (12731): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x70 -> 99 veces - -Offset 0x031BC (12732): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x70 -> 99 veces - -Offset 0x031BD (12733): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x6C -> 99 veces - -Offset 0x031BE (12734): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x65 -> 99 veces - -Offset 0x031BF (12735): - Valores distintos (2): 0x00, 0x54 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x54 -> 99 veces - -Offset 0x031C0 (12736): - Valores distintos (2): 0x00, 0x75 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x75 -> 99 veces - -Offset 0x031C1 (12737): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x6C -> 99 veces - -Offset 0x031C2 (12738): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x69 -> 99 veces - -Offset 0x031C3 (12739): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 135 veces - 0x70 -> 99 veces - -Offset 0x031E7 (12775): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x53 -> 118 veces - 0x00 -> 116 veces - -Offset 0x031E8 (12776): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x70 -> 118 veces - 0x00 -> 116 veces - -Offset 0x031E9 (12777): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x69 -> 118 veces - 0x00 -> 116 veces - -Offset 0x031EA (12778): - Valores distintos (2): 0x00, 0x74 - Clasificación: small_state - Más frecuentes: - 0x74 -> 118 veces - 0x00 -> 116 veces - -Offset 0x031EB (12779): - Valores distintos (2): 0x00, 0x7A - Clasificación: small_state - Más frecuentes: - 0x7A -> 118 veces - 0x00 -> 116 veces - -Offset 0x03205 (12805): - Valores distintos (2): 0x00, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x57 -> 114 veces - -Offset 0x03206 (12806): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x61 -> 114 veces - -Offset 0x03207 (12807): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x6C -> 114 veces - -Offset 0x03208 (12808): - Valores distintos (2): 0x00, 0x64 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x64 -> 114 veces - -Offset 0x03209 (12809): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0xFF -> 114 veces - -Offset 0x0320A (12810): - Valores distintos (2): 0x00, 0x52 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x52 -> 114 veces - -Offset 0x0320B (12811): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x65 -> 114 veces - -Offset 0x0320C (12812): - Valores distintos (2): 0x00, 0x62 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x62 -> 114 veces - -Offset 0x0320D (12813): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0x65 -> 114 veces - -Offset 0x0320E (12814): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 120 veces - 0xFF -> 114 veces - -Offset 0x0320F (12815): - Valores distintos (2): 0x00, 0x59 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x59 -> 107 veces - -Offset 0x03210 (12816): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x69 -> 107 veces - -Offset 0x03211 (12817): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x70 -> 107 veces - -Offset 0x03212 (12818): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0xFF -> 107 veces - -Offset 0x03213 (12819): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0xFF -> 107 veces - -Offset 0x03214 (12820): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x53 -> 118 veces - 0x00 -> 116 veces - -Offset 0x03215 (12821): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x63 -> 118 veces - 0x00 -> 116 veces - -Offset 0x03216 (12822): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x61 -> 118 veces - 0x00 -> 116 veces - -Offset 0x03217 (12823): - Valores distintos (2): 0x00, 0x74 - Clasificación: small_state - Más frecuentes: - 0x74 -> 118 veces - 0x00 -> 116 veces - -Offset 0x03218 (12824): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 118 veces - 0x00 -> 116 veces - -Offset 0x03219 (12825): - Valores distintos (2): 0x00, 0x50 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x50 -> 94 veces - -Offset 0x0321A (12826): - Valores distintos (2): 0x00, 0x66 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x66 -> 94 veces - -Offset 0x0321B (12827): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x61 -> 94 veces - -Offset 0x0321C (12828): - Valores distintos (2): 0x00, 0x75 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x75 -> 94 veces - -Offset 0x0321D (12829): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0xFF -> 94 veces - -Offset 0x0321E (12830): - Valores distintos (2): 0x00, 0x44 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x44 -> 85 veces - -Offset 0x0321F (12831): - Valores distintos (2): 0x00, 0x72 - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x72 -> 85 veces - -Offset 0x03220 (12832): - Valores distintos (2): 0x00, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x3E -> 85 veces - -Offset 0x03221 (12833): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x4B -> 85 veces - -Offset 0x03222 (12834): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0xFF -> 85 veces - -Offset 0x03223 (12835): - Valores distintos (2): 0x00, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x41 -> 107 veces - -Offset 0x03224 (12836): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x70 -> 107 veces - -Offset 0x03225 (12837): - Valores distintos (2): 0x00, 0x66 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x66 -> 107 veces - -Offset 0x03226 (12838): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x65 -> 107 veces - -Offset 0x03227 (12839): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x6C -> 107 veces - -Offset 0x03228 (12840): - Valores distintos (2): 0x00, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x4D -> 94 veces - -Offset 0x03229 (12841): - Valores distintos (2): 0x00, 0x72 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x72 -> 94 veces - -Offset 0x0322A (12842): - Valores distintos (2): 0x00, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x3E -> 94 veces - -Offset 0x0322B (12843): - Valores distintos (2): 0x00, 0x51 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x51 -> 94 veces - -Offset 0x0322C (12844): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0xFF -> 94 veces - -Offset 0x0402D (16429): - Valores distintos (8): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56 - Clasificación: small_state - Más frecuentes: - 0x4F -> 51 veces - 0x50 -> 43 veces - 0x51 -> 43 veces - 0x52 -> 31 veces - 0x53 -> 30 veces - -Offset 0x0402F (16431): - Valores distintos (9): 0x4F, 0x50, 0x51, 0x52, 0x54, 0x55, 0x56, 0x57, 0x58 - Clasificación: bitfield_like - Más frecuentes: - 0x52 -> 46 veces - 0x4F -> 45 veces - 0x51 -> 40 veces - 0x56 -> 38 veces - 0x58 -> 29 veces - -Offset 0x04033 (16435): - Valores distintos (6): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54 - Clasificación: small_state - Más frecuentes: - 0x51 -> 62 veces - 0x4F -> 61 veces - 0x52 -> 40 veces - 0x53 -> 38 veces - 0x50 -> 19 veces - -Offset 0x04035 (16437): - Valores distintos (10): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58 - Clasificación: bitfield_like - Más frecuentes: - 0x4F -> 54 veces - 0x57 -> 40 veces - 0x51 -> 28 veces - 0x55 -> 27 veces - 0x56 -> 27 veces - -Offset 0x04041 (16449): - Valores distintos (6): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54 - Clasificación: small_state - Más frecuentes: - 0x51 -> 71 veces - 0x52 -> 61 veces - 0x50 -> 37 veces - 0x4F -> 29 veces - 0x53 -> 25 veces - -Offset 0x04043 (16451): - Valores distintos (9): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57 - Clasificación: bitfield_like - Más frecuentes: - 0x55 -> 56 veces - 0x56 -> 36 veces - 0x4F -> 36 veces - 0x53 -> 32 veces - 0x51 -> 32 veces - -Offset 0x04200 (16896): - Valores distintos (13): 0x01, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0C, 0x0D, 0x0E, 0x0F - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 39 veces - 0x05 -> 37 veces - 0x09 -> 30 veces - 0x01 -> 29 veces - 0x0D -> 28 veces - -Offset 0x04201 (16897): - Valores distintos (2): 0x00, 0x40 - Clasificación: small_state - Más frecuentes: - 0x40 -> 124 veces - 0x00 -> 110 veces - -Offset 0x04204 (16900): - Valores distintos (3): 0x00, 0x01, 0x17 - Clasificación: small_state - Más frecuentes: - 0x00 -> 227 veces - 0x17 -> 6 veces - 0x01 -> 1 veces - -Offset 0x04205 (16901): - Valores distintos (3): 0x00, 0x03, 0x1D - Clasificación: small_state - Más frecuentes: - 0x00 -> 227 veces - 0x03 -> 6 veces - 0x1D -> 1 veces - -Offset 0x04206 (16902): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 218 veces - 0xFF -> 16 veces - -Offset 0x04207 (16903): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 218 veces - 0xFF -> 16 veces - -Offset 0x04208 (16904): - Valores distintos (30): 0x0D, 0x0F, 0x15, 0x16, 0x1C, 0x1D, 0x1E, 0x26, 0x2A, 0x34, 0x39, 0x42, 0x49, 0x4B, 0x52, 0x53, 0x5F, 0x60, 0x67, 0x6B, 0x6F, 0x76, 0x79, 0x91, 0x93, 0xA2, 0xBD, 0xBE, 0xD4, 0xEF - Clasificación: bitfield_like - Más frecuentes: - 0x76 -> 31 veces - 0x42 -> 25 veces - 0x79 -> 20 veces - 0x15 -> 18 veces - 0x49 -> 16 veces - -Offset 0x04209 (16905): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 183 veces - 0x01 -> 32 veces - 0x03 -> 16 veces - 0x02 -> 3 veces - -Offset 0x04213 (16915): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x0A -> 118 veces - 0x00 -> 116 veces - -Offset 0x04214 (16916): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 118 veces - 0x00 -> 116 veces - -Offset 0x04215 (16917): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 118 veces - 0x00 -> 116 veces - -Offset 0x04220 (16928): - Valores distintos (6): 0x00, 0x01, 0x07, 0x09, 0x28, 0xC8 - Clasificación: small_state - Más frecuentes: - 0x00 -> 160 veces - 0x07 -> 25 veces - 0x01 -> 20 veces - 0x28 -> 18 veces - 0xC8 -> 6 veces - -Offset 0x04224 (16932): - Valores distintos (18): 0x0A, 0x17, 0x28, 0x29, 0x32, 0x39, 0x3A, 0x4F, 0x5A, 0x6C, 0x75, 0x8F, 0x99, 0x9A, 0x9B, 0xA8, 0xBC, 0xBF - Clasificación: bitfield_like - Más frecuentes: - 0x5A -> 28 veces - 0xA8 -> 28 veces - 0x75 -> 25 veces - 0x99 -> 21 veces - 0x4F -> 20 veces - -Offset 0x04227 (16935): - Valores distintos (4): 0x01, 0x03, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x03 -> 98 veces - 0x07 -> 62 veces - 0x01 -> 46 veces - 0x05 -> 28 veces - -Offset 0x04229 (16937): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 224 veces - 0x80 -> 10 veces - -Offset 0x0422A (16938): - Valores distintos (17): 0x05, 0x07, 0x1A, 0x21, 0x25, 0x2B, 0x2F, 0x3C, 0x3F, 0x40, 0x4A, 0x57, 0x58, 0x59, 0x62, 0xAC, 0xAE - Clasificación: bitfield_like - Más frecuentes: - 0x3F -> 55 veces - 0x62 -> 28 veces - 0x59 -> 25 veces - 0x05 -> 20 veces - 0x1A -> 18 veces - -Offset 0x0422D (16941): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 145 veces - 0x80 -> 89 veces - -Offset 0x0422E (16942): - Valores distintos (15): 0x04, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x14, 0x1B, 0x1C, 0x21, 0x27, 0x3E, 0x50, 0x60 - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 48 veces - 0x10 -> 32 veces - 0x0C -> 31 veces - 0x0F -> 25 veces - 0x14 -> 20 veces - -Offset 0x04230 (16944): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x07 -> 83 veces - -Offset 0x04231 (16945): - Valores distintos (4): 0x00, 0x04, 0x05, 0x08 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x05 -> 65 veces - 0x04 -> 11 veces - 0x08 -> 7 veces - -Offset 0x04232 (16946): - Valores distintos (3): 0x00, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x06 -> 65 veces - 0x05 -> 18 veces - -Offset 0x04233 (16947): - Valores distintos (2): 0x00, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x06 -> 76 veces - -Offset 0x04234 (16948): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x07 -> 76 veces - -Offset 0x04235 (16949): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x05 -> 76 veces - -Offset 0x04270 (17008): - Valores distintos (33): 0x26, 0x27, 0x30, 0x33, 0x36, 0x38, 0x4A, 0x4B, 0x4E, 0x56, 0x5B, 0x6F, 0x70, 0x7A, 0x7B, 0x83, 0x87, 0x8E, 0x9C, 0xB3, 0xB5, 0xBB, 0xC1, 0xC3, 0xC9, 0xCC, 0xD0, 0xE3, 0xED, 0xEF, 0xF1, 0xF8, 0xFB - Clasificación: bitfield_like - Más frecuentes: - 0xED -> 25 veces - 0xE3 -> 20 veces - 0x5B -> 18 veces - 0xFB -> 17 veces - 0x4E -> 16 veces - -Offset 0x04271 (17009): - Valores distintos (29): 0x33, 0x55, 0x59, 0x5E, 0x5F, 0x69, 0x75, 0x79, 0x7E, 0x87, 0x89, 0x8C, 0x8D, 0x8E, 0x92, 0x96, 0x9B, 0xA8, 0xAC, 0xAD, 0xAE, 0xB0, 0xB6, 0xB7, 0xCD, 0xD4, 0xDF, 0xE9, 0xF2 - Clasificación: bitfield_like - Más frecuentes: - 0xAD -> 26 veces - 0xF2 -> 25 veces - 0xB7 -> 21 veces - 0x8E -> 18 veces - 0x92 -> 17 veces - -Offset 0x04295 (17045): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 137 veces - 0x00 -> 97 veces - -Offset 0x04296 (17046): - Valores distintos (25): 0x03, 0x04, 0x06, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x14, 0x15, 0x16, 0x18, 0x19, 0x1A, 0x1E, 0x1F, 0x20, 0x22, 0x24, 0x25, 0x26, 0x2A, 0x2E, 0x2F, 0x34 - Clasificación: bitfield_like - Más frecuentes: - 0x1A -> 25 veces - 0x14 -> 22 veces - 0x06 -> 21 veces - 0x2F -> 17 veces - 0x22 -> 16 veces - -Offset 0x04298 (17048): - Valores distintos (32): 0x03, 0x06, 0x0C, 0x0D, 0x0F, 0x21, 0x2A, 0x30, 0x46, 0x48, 0x4C, 0x5D, 0x63, 0x6C, 0x75, 0x80, 0x93, 0x96, 0x98, 0x9B, 0x9E, 0xBD, 0xC3, 0xC7, 0xCE, 0xD0, 0xD2, 0xE2, 0xEA, 0xEE, 0xF6, 0xF7 - Clasificación: bitfield_like - Más frecuentes: - 0x0C -> 31 veces - 0x98 -> 25 veces - 0x96 -> 20 veces - 0x0D -> 18 veces - 0xF6 -> 16 veces - -Offset 0x04299 (17049): - Valores distintos (27): 0x00, 0x01, 0x02, 0x09, 0x0C, 0x10, 0x13, 0x14, 0x19, 0x2B, 0x2C, 0x35, 0x37, 0x39, 0x3C, 0x42, 0x51, 0x65, 0x66, 0x73, 0x7C, 0xAE, 0xC1, 0xDE, 0xE3, 0xF0, 0xFB - Clasificación: bitfield_like - Más frecuentes: - 0x73 -> 25 veces - 0x2C -> 20 veces - 0x65 -> 19 veces - 0x01 -> 18 veces - 0x37 -> 16 veces - -Offset 0x0429A (17050): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x01 -> 21 veces - 0x06 -> 17 veces - 0x0A -> 11 veces - 0x02 -> 9 veces - -Offset 0x0429E (17054): - Valores distintos (11): 0x01, 0x03, 0x06, 0x07, 0x09, 0x0A, 0x0C, 0x12, 0x14, 0x18, 0x45 - Clasificación: bitfield_like - Más frecuentes: - 0x0A -> 57 veces - 0x18 -> 49 veces - 0x06 -> 44 veces - 0x45 -> 23 veces - 0x12 -> 16 veces - -Offset 0x0429F (17055): - Valores distintos (8): 0x00, 0x32, 0x33, 0x36, 0x37, 0x3A, 0x3D, 0x41 - Clasificación: small_state - Más frecuentes: - 0x37 -> 57 veces - 0x36 -> 50 veces - 0x3D -> 36 veces - 0x33 -> 33 veces - 0x41 -> 30 veces - -Offset 0x042A0 (17056): - Valores distintos (7): 0x00, 0x21, 0x23, 0x26, 0x27, 0x2A, 0x31 - Clasificación: small_state - Más frecuentes: - 0x27 -> 54 veces - 0x26 -> 53 veces - 0x2A -> 53 veces - 0x23 -> 36 veces - 0x31 -> 30 veces - -Offset 0x042A1 (17057): - Valores distintos (7): 0x01, 0x02, 0x08, 0x0C, 0x10, 0x12, 0x1F - Clasificación: small_state - Más frecuentes: - 0x08 -> 50 veces - 0x1F -> 49 veces - 0x10 -> 44 veces - 0x02 -> 36 veces - 0x12 -> 34 veces - -Offset 0x042A2 (17058): - Valores distintos (7): 0x00, 0x05, 0x09, 0x0B, 0x0E, 0x12, 0x18 - Clasificación: small_state - Más frecuentes: - 0x12 -> 49 veces - 0x0B -> 47 veces - 0x05 -> 39 veces - 0x18 -> 37 veces - 0x00 -> 29 veces - -Offset 0x042A3 (17059): - Valores distintos (4): 0x00, 0x0A, 0x10, 0x13 - Clasificación: small_state - Más frecuentes: - 0x13 -> 172 veces - 0x00 -> 44 veces - 0x0A -> 11 veces - 0x10 -> 7 veces - -Offset 0x042A4 (17060): - Valores distintos (26): 0x04, 0x06, 0x19, 0x25, 0x4A, 0x51, 0x57, 0x60, 0x61, 0x71, 0x80, 0x81, 0x86, 0x9F, 0xA5, 0xB0, 0xCA, 0xD2, 0xD3, 0xD5, 0xDA, 0xE9, 0xEA, 0xF2, 0xF9, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0xB0 -> 25 veces - 0x80 -> 22 veces - 0x25 -> 21 veces - 0xFD -> 17 veces - 0xCA -> 16 veces - -Offset 0x042A5 (17061): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x042A6 (17062): - Valores distintos (23): 0x00, 0x0B, 0x0C, 0x14, 0x2B, 0x2E, 0x31, 0x35, 0x37, 0x3A, 0x3F, 0x43, 0x4E, 0x50, 0x57, 0x5E, 0x7A, 0x82, 0x88, 0xA0, 0xB4, 0xB8, 0xC4 - Clasificación: bitfield_like - Más frecuentes: - 0x43 -> 30 veces - 0x35 -> 22 veces - 0x14 -> 21 veces - 0xB8 -> 17 veces - 0x31 -> 16 veces - -Offset 0x042A8 (17064): - Valores distintos (2): 0x01, 0x0B - Clasificación: small_state - Más frecuentes: - 0x01 -> 195 veces - 0x0B -> 39 veces - -Offset 0x042AA (17066): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 208 veces - 0x01 -> 26 veces - -Offset 0x042AB (17067): - Valores distintos (4): 0x00, 0x09, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 122 veces - 0x09 -> 64 veces - 0xFF -> 29 veces - 0x10 -> 19 veces - -Offset 0x042AC (17068): - Valores distintos (26): 0x04, 0x19, 0x1D, 0x25, 0x4A, 0x51, 0x57, 0x60, 0x67, 0x80, 0x86, 0x8F, 0x9F, 0xA5, 0xB0, 0xC4, 0xCA, 0xD2, 0xD5, 0xDA, 0xE7, 0xE9, 0xEA, 0xF2, 0xF9, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0xB0 -> 25 veces - 0x80 -> 22 veces - 0x25 -> 21 veces - 0xFD -> 17 veces - 0xCA -> 16 veces - -Offset 0x042AD (17069): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x042AE (17070): - Valores distintos (22): 0x0C, 0x0F, 0x14, 0x2B, 0x2E, 0x2F, 0x35, 0x37, 0x3A, 0x3F, 0x43, 0x4E, 0x57, 0x5E, 0x6C, 0x7A, 0x82, 0x88, 0xA0, 0xB4, 0xB8, 0xC4 - Clasificación: bitfield_like - Más frecuentes: - 0x43 -> 30 veces - 0x35 -> 22 veces - 0x14 -> 21 veces - 0xB8 -> 17 veces - 0x6C -> 16 veces - -Offset 0x042B0 (17072): - Valores distintos (25): 0x00, 0x12, 0x15, 0x18, 0x19, 0x34, 0x37, 0x3C, 0x4F, 0x53, 0x55, 0x57, 0x68, 0x69, 0x75, 0x77, 0x7C, 0x7D, 0x98, 0x9C, 0xA4, 0xBD, 0xC4, 0xCF, 0xD5 - Clasificación: bitfield_like - Más frecuentes: - 0xA4 -> 25 veces - 0x68 -> 22 veces - 0x18 -> 21 veces - 0x77 -> 17 veces - 0x00 -> 16 veces - -Offset 0x042B1 (17073): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 168 veces - 0x01 -> 66 veces - -Offset 0x042B2 (17074): - Valores distintos (22): 0x0D, 0x10, 0x18, 0x1A, 0x2A, 0x2F, 0x32, 0x4F, 0x52, 0x5D, 0x61, 0x6B, 0x77, 0x89, 0x8D, 0x9C, 0xBA, 0xBF, 0xC0, 0xE3, 0xFA, 0xFC - Clasificación: bitfield_like - Más frecuentes: - 0x8D -> 25 veces - 0x5D -> 22 veces - 0xE3 -> 19 veces - 0xFA -> 19 veces - 0x1A -> 18 veces - -Offset 0x042B4 (17076): - Valores distintos (20): 0x04, 0x05, 0x06, 0x0B, 0x0D, 0x0E, 0x0F, 0x11, 0x16, 0x1B, 0x1D, 0x1F, 0x20, 0x22, 0x24, 0x27, 0x2B, 0x34, 0x36, 0x42 - Clasificación: bitfield_like - Más frecuentes: - 0x16 -> 40 veces - 0x0F -> 24 veces - 0x11 -> 22 veces - 0x04 -> 18 veces - 0x36 -> 17 veces - -Offset 0x042B6 (17078): - Valores distintos (20): 0x0D, 0x10, 0x13, 0x24, 0x25, 0x27, 0x2A, 0x2D, 0x2E, 0x32, 0x37, 0x3E, 0x4B, 0x56, 0x5D, 0x60, 0x7C, 0x8C, 0x90, 0x9D - Clasificación: bitfield_like - Más frecuentes: - 0x27 -> 44 veces - 0x2E -> 30 veces - 0x13 -> 21 veces - 0x90 -> 17 veces - 0x4B -> 16 veces - -Offset 0x042BA (17082): - Valores distintos (2): 0x01, 0x0B - Clasificación: small_state - Más frecuentes: - 0x01 -> 195 veces - 0x0B -> 39 veces - -Offset 0x042BB (17083): - Valores distintos (3): 0x02, 0x04, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 144 veces - 0x07 -> 77 veces - 0x04 -> 13 veces - -Offset 0x042BC (17084): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 223 veces - 0x07 -> 11 veces - -Offset 0x042C2 (17090): - Valores distintos (2): 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x02 -> 227 veces - 0x05 -> 7 veces - -Offset 0x042C3 (17091): - Valores distintos (2): 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x02 -> 223 veces - 0x05 -> 11 veces - -Offset 0x042C4 (17092): - Valores distintos (4): 0x32, 0x37, 0x46, 0x4B - Clasificación: small_state - Más frecuentes: - 0x37 -> 97 veces - 0x32 -> 88 veces - 0x4B -> 40 veces - 0x46 -> 9 veces - -Offset 0x042C7 (17095): - Valores distintos (3): 0x06, 0x08, 0x12 - Clasificación: small_state - Más frecuentes: - 0x08 -> 118 veces - 0x06 -> 97 veces - 0x12 -> 19 veces - -Offset 0x042C8 (17096): - Valores distintos (2): 0x5F, 0x64 - Clasificación: small_state - Más frecuentes: - 0x64 -> 183 veces - 0x5F -> 51 veces - -Offset 0x042CC (17100): - Valores distintos (25): 0x04, 0x19, 0x1D, 0x25, 0x4A, 0x51, 0x57, 0x60, 0x67, 0x80, 0x86, 0x8F, 0x9F, 0xA5, 0xB0, 0xD2, 0xD5, 0xDA, 0xE1, 0xE7, 0xE9, 0xEA, 0xF2, 0xF9, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0xB0 -> 25 veces - 0x80 -> 22 veces - 0x25 -> 21 veces - 0xFD -> 17 veces - 0xE1 -> 16 veces - -Offset 0x042CD (17101): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x042CE (17102): - Valores distintos (22): 0x0C, 0x0F, 0x14, 0x2B, 0x2E, 0x2F, 0x35, 0x37, 0x3A, 0x3F, 0x43, 0x4E, 0x57, 0x5E, 0x6C, 0x7A, 0x82, 0x88, 0xA0, 0xB4, 0xB8, 0xC4 - Clasificación: bitfield_like - Más frecuentes: - 0x43 -> 30 veces - 0x35 -> 22 veces - 0x14 -> 21 veces - 0xB8 -> 17 veces - 0x6C -> 16 veces - -Offset 0x042D0 (17104): - Valores distintos (25): 0x0E, 0x0F, 0x12, 0x2C, 0x2F, 0x34, 0x38, 0x3E, 0x51, 0x56, 0x5C, 0x68, 0x6C, 0x74, 0x8D, 0x94, 0x9A, 0xA5, 0xB0, 0xB5, 0xB9, 0xCB, 0xD7, 0xD9, 0xDF - Clasificación: bitfield_like - Más frecuentes: - 0x74 -> 25 veces - 0x51 -> 22 veces - 0x12 -> 21 veces - 0xD9 -> 17 veces - 0xA5 -> 16 veces - -Offset 0x042D2 (17106): - Valores distintos (18): 0x0B, 0x0C, 0x10, 0x20, 0x25, 0x28, 0x2D, 0x30, 0x3B, 0x3F, 0x42, 0x48, 0x4C, 0x50, 0x5F, 0x60, 0x62, 0x64 - Clasificación: bitfield_like - Más frecuentes: - 0x5F -> 47 veces - 0x50 -> 25 veces - 0x3B -> 22 veces - 0x10 -> 21 veces - 0x60 -> 20 veces - -Offset 0x042D4 (17108): - Valores distintos (19): 0x0A, 0x0B, 0x13, 0x16, 0x18, 0x1A, 0x1D, 0x21, 0x26, 0x28, 0x2A, 0x2E, 0x33, 0x34, 0x38, 0x3F, 0x49, 0x4B, 0x57 - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 40 veces - 0x1A -> 28 veces - 0x0B -> 21 veces - 0x4B -> 17 veces - 0x2E -> 16 veces - -Offset 0x042D6 (17110): - Valores distintos (20): 0x0D, 0x10, 0x13, 0x24, 0x25, 0x27, 0x2A, 0x2D, 0x2E, 0x32, 0x37, 0x3E, 0x4B, 0x56, 0x5D, 0x60, 0x7C, 0x8C, 0x90, 0x9D - Clasificación: bitfield_like - Más frecuentes: - 0x27 -> 44 veces - 0x2E -> 30 veces - 0x13 -> 21 veces - 0x90 -> 17 veces - 0x4B -> 16 veces - -Offset 0x042E4 (17124): - Valores distintos (2): 0x32, 0x37 - Clasificación: small_state - Más frecuentes: - 0x37 -> 137 veces - 0x32 -> 97 veces - -Offset 0x042E7 (17127): - Valores distintos (2): 0x06, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 137 veces - 0x06 -> 97 veces - -Offset 0x042E8 (17128): - Valores distintos (2): 0x5F, 0x64 - Clasificación: small_state - Más frecuentes: - 0x64 -> 137 veces - 0x5F -> 97 veces - -Offset 0x042ED (17133): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x4B -> 228 veces - 0x00 -> 6 veces - -Offset 0x042EE (17134): - Valores distintos (2): 0x00, 0x47 - Clasificación: small_state - Más frecuentes: - 0x47 -> 205 veces - 0x00 -> 29 veces - -Offset 0x042EF (17135): - Valores distintos (2): 0x00, 0x4C - Clasificación: small_state - Más frecuentes: - 0x4C -> 168 veces - 0x00 -> 66 veces - -Offset 0x042F0 (17136): - Valores distintos (2): 0x00, 0x73 - Clasificación: small_state - Más frecuentes: - 0x73 -> 168 veces - 0x00 -> 66 veces - -Offset 0x042F1 (17137): - Valores distintos (2): 0x00, 0x49 - Clasificación: small_state - Más frecuentes: - 0x49 -> 137 veces - 0x00 -> 97 veces - -Offset 0x042F2 (17138): - Valores distintos (2): 0x00, 0x48 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x48 -> 97 veces - -Offset 0x042F3 (17139): - Valores distintos (2): 0x00, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x4D -> 83 veces - -Offset 0x042F4 (17140): - Valores distintos (2): 0x00, 0x4A - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x4A -> 66 veces - -Offset 0x042F6 (17142): - Valores distintos (2): 0x00, 0x52 - Clasificación: small_state - Más frecuentes: - 0x52 -> 226 veces - 0x00 -> 8 veces - -Offset 0x042F7 (17143): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x53 -> 190 veces - 0x00 -> 44 veces - -Offset 0x042F8 (17144): - Valores distintos (2): 0x00, 0x56 - Clasificación: small_state - Más frecuentes: - 0x56 -> 122 veces - 0x00 -> 112 veces - -Offset 0x04300 (17152): - Valores distintos (2): 0x00, 0x97 - Clasificación: small_state - Más frecuentes: - 0x97 -> 205 veces - 0x00 -> 29 veces - -Offset 0x04301 (17153): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x15 -> 50 veces - -Offset 0x0430A (17162): - Valores distintos (2): 0x00, 0x77 - Clasificación: small_state - Más frecuentes: - 0x77 -> 205 veces - 0x00 -> 29 veces - -Offset 0x0430B (17163): - Valores distintos (2): 0x00, 0xAA - Clasificación: small_state - Más frecuentes: - 0xAA -> 194 veces - 0x00 -> 40 veces - -Offset 0x0430C (17164): - Valores distintos (2): 0x00, 0x27 - Clasificación: small_state - Más frecuentes: - 0x27 -> 200 veces - 0x00 -> 34 veces - -Offset 0x0430D (17165): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 146 veces - 0x00 -> 88 veces - -Offset 0x0430E (17166): - Valores distintos (2): 0x00, 0x14 - Clasificación: small_state - Más frecuentes: - 0x14 -> 135 veces - 0x00 -> 99 veces - -Offset 0x0430F (17167): - Valores distintos (3): 0x00, 0x45, 0xC3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 129 veces - 0xC3 -> 66 veces - 0x45 -> 39 veces - -Offset 0x04310 (17168): - Valores distintos (2): 0x00, 0xC6 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0xC6 -> 50 veces - -Offset 0x04311 (17169): - Valores distintos (2): 0x00, 0xC9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0xC9 -> 36 veces - -Offset 0x04312 (17170): - Valores distintos (2): 0x00, 0xCE - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xCE -> 30 veces - -Offset 0x04313 (17171): - Valores distintos (2): 0x00, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 215 veces - 0x3E -> 19 veces - -Offset 0x04314 (17172): - Valores distintos (5): 0x00, 0x09, 0x1E, 0x2D, 0x33 - Clasificación: small_state - Más frecuentes: - 0x09 -> 122 veces - 0x1E -> 53 veces - 0x00 -> 29 veces - 0x2D -> 19 veces - 0x33 -> 11 veces - -Offset 0x04315 (17173): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 122 veces - 0xFD -> 64 veces - 0x00 -> 29 veces - 0xFF -> 19 veces - -Offset 0x04316 (17174): - Valores distintos (3): 0x00, 0x03, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 122 veces - 0x03 -> 64 veces - 0x00 -> 48 veces - -Offset 0x04317 (17175): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 122 veces - 0x01 -> 64 veces - 0x00 -> 29 veces - 0xFF -> 19 veces - -Offset 0x04318 (17176): - Valores distintos (4): 0x00, 0x01, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 122 veces - 0xFD -> 64 veces - 0x00 -> 29 veces - 0xFF -> 19 veces - -Offset 0x04319 (17177): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 64 veces - 0x02 -> 19 veces - -Offset 0x0431A (17178): - Valores distintos (3): 0x00, 0x03, 0xFD - Clasificación: small_state - Más frecuentes: - 0xFD -> 122 veces - 0x03 -> 64 veces - 0x00 -> 48 veces - -Offset 0x04339 (17209): - Valores distintos (2): 0x01, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 137 veces - 0x01 -> 97 veces - -Offset 0x0433A (17210): - Valores distintos (13): 0x05, 0x0A, 0x0D, 0x0E, 0x0F, 0x10, 0x16, 0x18, 0x1A, 0x23, 0x25, 0x26, 0x28 - Clasificación: bitfield_like - Más frecuentes: - 0x05 -> 44 veces - 0x10 -> 43 veces - 0x1A -> 30 veces - 0x0E -> 22 veces - 0x18 -> 17 veces - -Offset 0x0433B (17211): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 180 veces - 0x00 -> 54 veces - -Offset 0x0433C (17212): - Valores distintos (16): 0x0A, 0x0F, 0x25, 0x3B, 0x3F, 0x55, 0x5A, 0x60, 0x6B, 0x6D, 0x79, 0x92, 0x95, 0xBD, 0xCD, 0xF7 - Clasificación: bitfield_like - Más frecuentes: - 0x5A -> 44 veces - 0xBD -> 30 veces - 0x0F -> 30 veces - 0x6D -> 27 veces - 0x95 -> 20 veces - -Offset 0x0433D (17213): - Valores distintos (16): 0x00, 0x03, 0x04, 0x09, 0x0B, 0x0C, 0x10, 0x12, 0x13, 0x3B, 0x4C, 0x4D, 0x6F, 0x98, 0xA0, 0xD6 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 44 veces - 0x13 -> 30 veces - 0x6F -> 30 veces - 0x0C -> 20 veces - 0x4D -> 17 veces - -Offset 0x0433E (17214): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 25 veces - 0x02 -> 11 veces - -Offset 0x04342 (17218): - Valores distintos (5): 0x1E, 0x20, 0x21, 0x26, 0x28 - Clasificación: small_state - Más frecuentes: - 0x26 -> 61 veces - 0x21 -> 49 veces - 0x1E -> 44 veces - 0x20 -> 44 veces - 0x28 -> 36 veces - -Offset 0x04343 (17219): - Valores distintos (5): 0x00, 0x32, 0x36, 0x38, 0x3C - Clasificación: small_state - Más frecuentes: - 0x38 -> 61 veces - 0x36 -> 49 veces - 0x00 -> 44 veces - 0x32 -> 44 veces - 0x3C -> 36 veces - -Offset 0x04344 (17220): - Valores distintos (5): 0x00, 0x26, 0x28, 0x29, 0x2C - Clasificación: small_state - Más frecuentes: - 0x26 -> 63 veces - 0x28 -> 61 veces - 0x00 -> 44 veces - 0x2C -> 36 veces - 0x29 -> 30 veces - -Offset 0x04345 (17221): - Valores distintos (5): 0x05, 0x06, 0x0B, 0x12, 0x16 - Clasificación: small_state - Más frecuentes: - 0x0B -> 63 veces - 0x12 -> 47 veces - 0x05 -> 44 veces - 0x06 -> 44 veces - 0x16 -> 36 veces - -Offset 0x04346 (17222): - Valores distintos (4): 0x00, 0x10, 0x14, 0x18 - Clasificación: small_state - Más frecuentes: - 0x10 -> 100 veces - 0x00 -> 81 veces - 0x18 -> 51 veces - 0x14 -> 2 veces - -Offset 0x04347 (17223): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 127 veces - 0x02 -> 107 veces - -Offset 0x04348 (17224): - Valores distintos (15): 0x1B, 0x27, 0x2D, 0x3B, 0x3F, 0x42, 0x55, 0x58, 0x5A, 0x5C, 0x62, 0x97, 0x9D, 0xB4, 0xC0 - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 44 veces - 0x42 -> 43 veces - 0x3B -> 22 veces - 0x5C -> 17 veces - 0xB4 -> 17 veces - -Offset 0x0434A (17226): - Valores distintos (13): 0x08, 0x1E, 0x21, 0x2B, 0x38, 0x4D, 0x52, 0x57, 0x7E, 0x8C, 0xA2, 0xF1, 0xF9 - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 44 veces - 0x57 -> 43 veces - 0xA2 -> 30 veces - 0x4D -> 22 veces - 0x8C -> 17 veces - -Offset 0x0434B (17227): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 206 veces - 0x01 -> 28 veces - -Offset 0x0434C (17228): - Valores distintos (2): 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 218 veces - 0x01 -> 16 veces - -Offset 0x0434E (17230): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 218 veces - 0x01 -> 16 veces - -Offset 0x0434F (17231): - Valores distintos (5): 0x05, 0x06, 0x07, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 57 veces - 0x05 -> 50 veces - 0x08 -> 47 veces - 0xFF -> 44 veces - 0x06 -> 36 veces - -Offset 0x04350 (17232): - Valores distintos (14): 0x1B, 0x2D, 0x3A, 0x3B, 0x3F, 0x42, 0x55, 0x58, 0x5C, 0x62, 0x9D, 0xAB, 0xB4, 0xC0 - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 44 veces - 0x42 -> 43 veces - 0x3B -> 22 veces - 0x5C -> 17 veces - 0xB4 -> 17 veces - -Offset 0x04352 (17234): - Valores distintos (13): 0x01, 0x08, 0x1E, 0x21, 0x38, 0x45, 0x4D, 0x52, 0x57, 0x7E, 0x8C, 0xA2, 0xF1 - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 44 veces - 0x57 -> 43 veces - 0xA2 -> 30 veces - 0x4D -> 22 veces - 0x8C -> 17 veces - -Offset 0x04353 (17235): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x04354 (17236): - Valores distintos (9): 0x13, 0x2B, 0x33, 0x3D, 0x3F, 0x69, 0x6B, 0x86, 0x87 - Clasificación: bitfield_like - Más frecuentes: - 0x6B -> 47 veces - 0x13 -> 44 veces - 0x3F -> 43 veces - 0x33 -> 37 veces - 0x87 -> 30 veces - -Offset 0x04356 (17238): - Valores distintos (13): 0x13, 0x29, 0x2C, 0x2F, 0x45, 0x48, 0x50, 0x65, 0x7B, 0x7C, 0x94, 0x95, 0x96 - Clasificación: bitfield_like - Más frecuentes: - 0x13 -> 44 veces - 0x50 -> 30 veces - 0x7C -> 30 veces - 0x96 -> 28 veces - 0x2F -> 22 veces - -Offset 0x04358 (17240): - Valores distintos (10): 0x09, 0x0E, 0x11, 0x13, 0x14, 0x15, 0x17, 0x24, 0x26, 0x27 - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 44 veces - 0x14 -> 44 veces - 0x11 -> 43 veces - 0x17 -> 30 veces - 0x26 -> 19 veces - -Offset 0x0435A (17242): - Valores distintos (13): 0x18, 0x2C, 0x32, 0x36, 0x38, 0x3D, 0x59, 0x5F, 0x6F, 0xB0, 0xB5, 0xBA, 0xBF - Clasificación: bitfield_like - Más frecuentes: - 0x18 -> 44 veces - 0x3D -> 43 veces - 0x6F -> 30 veces - 0x38 -> 22 veces - 0x5F -> 17 veces - -Offset 0x0435C (17244): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 173 veces - 0x01 -> 61 veces - -Offset 0x04364 (17252): - Valores distintos (2): 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x05 -> 177 veces - 0x06 -> 57 veces - -Offset 0x04366 (17254): - Valores distintos (3): 0x02, 0x03, 0x05 - Clasificación: small_state - Más frecuentes: - 0x05 -> 100 veces - 0x02 -> 98 veces - 0x03 -> 36 veces - -Offset 0x04367 (17255): - Valores distintos (3): 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x02 -> 141 veces - 0x04 -> 57 veces - 0x03 -> 36 veces - -Offset 0x0436B (17259): - Valores distintos (2): 0x0A, 0x0C - Clasificación: small_state - Más frecuentes: - 0x0C -> 137 veces - 0x0A -> 97 veces - -Offset 0x04370 (17264): - Valores distintos (13): 0x1B, 0x2D, 0x3A, 0x3B, 0x3F, 0x42, 0x55, 0x5C, 0x62, 0x9D, 0xAB, 0xB4, 0xC0 - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 44 veces - 0x42 -> 43 veces - 0x62 -> 30 veces - 0x3B -> 22 veces - 0x5C -> 17 veces - -Offset 0x04372 (17266): - Valores distintos (13): 0x01, 0x08, 0x1E, 0x21, 0x38, 0x45, 0x4D, 0x52, 0x57, 0x7E, 0x8C, 0xA2, 0xF1 - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 44 veces - 0x57 -> 43 veces - 0xA2 -> 30 veces - 0x4D -> 22 veces - 0x8C -> 17 veces - -Offset 0x04373 (17267): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x04374 (17268): - Valores distintos (9): 0x0D, 0x17, 0x1F, 0x21, 0x23, 0x24, 0x26, 0x2C, 0x2D - Clasificación: bitfield_like - Más frecuentes: - 0x26 -> 47 veces - 0x0D -> 44 veces - 0x23 -> 43 veces - 0x1F -> 37 veces - 0x2D -> 30 veces - -Offset 0x04376 (17270): - Valores distintos (12): 0x0D, 0x14, 0x17, 0x1A, 0x1B, 0x1E, 0x29, 0x2A, 0x2B, 0x32, 0x33, 0x34 - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 44 veces - 0x1E -> 43 veces - 0x2B -> 30 veces - 0x34 -> 28 veces - 0x1A -> 22 veces - -Offset 0x04378 (17272): - Valores distintos (11): 0x0E, 0x14, 0x17, 0x1A, 0x1C, 0x21, 0x24, 0x26, 0x2E, 0x30, 0x31 - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 44 veces - 0x1C -> 43 veces - 0x17 -> 37 veces - 0x26 -> 30 veces - 0x30 -> 19 veces - -Offset 0x0437A (17274): - Valores distintos (13): 0x18, 0x29, 0x2F, 0x35, 0x36, 0x3D, 0x59, 0x5F, 0x6F, 0xA1, 0xA6, 0xAB, 0xB0 - Clasificación: bitfield_like - Más frecuentes: - 0x18 -> 44 veces - 0x3D -> 43 veces - 0x6F -> 30 veces - 0x35 -> 22 veces - 0x5F -> 17 veces - -Offset 0x0438B (17291): - Valores distintos (2): 0x0A, 0x0C - Clasificación: small_state - Más frecuentes: - 0x0C -> 137 veces - 0x0A -> 97 veces - -Offset 0x04390 (17296): - Valores distintos (2): 0x00, 0x4F - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x4F -> 97 veces - -Offset 0x04391 (17297): - Valores distintos (2): 0x00, 0x4E - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x4E -> 83 veces - -Offset 0x0439A (17306): - Valores distintos (2): 0x00, 0x59 - Clasificación: small_state - Más frecuentes: - 0x59 -> 190 veces - 0x00 -> 44 veces - -Offset 0x0439B (17307): - Valores distintos (2): 0x00, 0x5A - Clasificación: small_state - Más frecuentes: - 0x5A -> 190 veces - 0x00 -> 44 veces - -Offset 0x0439C (17308): - Valores distintos (2): 0x00, 0x58 - Clasificación: small_state - Más frecuentes: - 0x58 -> 183 veces - 0x00 -> 51 veces - -Offset 0x043A7 (17319): - Valores distintos (2): 0x00, 0x67 - Clasificación: small_state - Más frecuentes: - 0x67 -> 190 veces - 0x00 -> 44 veces - -Offset 0x043A8 (17320): - Valores distintos (2): 0x00, 0x5F - Clasificación: small_state - Más frecuentes: - 0x5F -> 183 veces - 0x00 -> 51 veces - -Offset 0x043A9 (17321): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x65 -> 146 veces - 0x00 -> 88 veces - -Offset 0x043AA (17322): - Valores distintos (2): 0x00, 0x62 - Clasificación: small_state - Más frecuentes: - 0x62 -> 140 veces - 0x00 -> 94 veces - -Offset 0x043AB (17323): - Valores distintos (2): 0x00, 0x60 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x60 -> 36 veces - -Offset 0x043AC (17324): - Valores distintos (2): 0x00, 0x68 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x68 -> 36 veces - -Offset 0x043AD (17325): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x63 -> 30 veces - -Offset 0x043AE (17326): - Valores distintos (3): 0x00, 0x0A, 0x29 - Clasificación: small_state - Más frecuentes: - 0x0A -> 135 veces - 0x00 -> 88 veces - 0x29 -> 11 veces - -Offset 0x043AF (17327): - Valores distintos (3): 0x00, 0x3F, 0xA4 - Clasificación: small_state - Más frecuentes: - 0xA4 -> 135 veces - 0x00 -> 88 veces - 0x3F -> 11 veces - -Offset 0x043B0 (17328): - Valores distintos (2): 0x00, 0xA5 - Clasificación: small_state - Más frecuentes: - 0xA5 -> 146 veces - 0x00 -> 88 veces - -Offset 0x043B1 (17329): - Valores distintos (2): 0x00, 0xB3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xB3 -> 97 veces - -Offset 0x043B2 (17330): - Valores distintos (2): 0x00, 0xCF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xCF -> 97 veces - -Offset 0x043B3 (17331): - Valores distintos (2): 0x00, 0xA9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xA9 -> 83 veces - -Offset 0x043B4 (17332): - Valores distintos (2): 0x00, 0xBC - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0xBC -> 66 veces - -Offset 0x043B5 (17333): - Valores distintos (2): 0x00, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x06 -> 36 veces - -Offset 0x043B6 (17334): - Valores distintos (2): 0x00, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x28 -> 36 veces - -Offset 0x043B7 (17335): - Valores distintos (2): 0x00, 0x8C - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x8C -> 11 veces - -Offset 0x043B8 (17336): - Valores distintos (5): 0x00, 0x08, 0x10, 0x18, 0x1E - Clasificación: small_state - Más frecuentes: - 0x10 -> 57 veces - 0x08 -> 50 veces - 0x18 -> 47 veces - 0x00 -> 44 veces - 0x1E -> 36 veces - -Offset 0x043B9 (17337): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x04 -> 36 veces - -Offset 0x043BA (17338): - Valores distintos (4): 0x00, 0x01, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x01 -> 57 veces - 0x04 -> 47 veces - 0x03 -> 36 veces - -Offset 0x043BB (17339): - Valores distintos (3): 0x00, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 104 veces - 0x00 -> 94 veces - 0xFF -> 36 veces - -Offset 0x043BC (17340): - Valores distintos (3): 0x00, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xFE -> 47 veces - 0xFF -> 36 veces - -Offset 0x043BD (17341): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0xFF -> 36 veces - -Offset 0x043BE (17342): - Valores distintos (4): 0x00, 0x01, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x01 -> 57 veces - 0x04 -> 47 veces - 0xFF -> 36 veces - -Offset 0x043DE (17374): - Valores distintos (12): 0x0D, 0x0F, 0x10, 0x11, 0x13, 0x15, 0x16, 0x18, 0x22, 0x24, 0x27, 0x2C - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 88 veces - 0x16 -> 47 veces - 0x15 -> 30 veces - 0x27 -> 17 veces - 0x18 -> 14 veces - -Offset 0x043DF (17375): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 146 veces - 0x00 -> 88 veces - -Offset 0x043E0 (17376): - Valores distintos (13): 0x25, 0x45, 0x6D, 0x78, 0xA7, 0xB7, 0xB8, 0xD5, 0xD8, 0xD9, 0xE1, 0xE3, 0xE9 - Clasificación: bitfield_like - Más frecuentes: - 0xB8 -> 88 veces - 0x45 -> 33 veces - 0xD9 -> 30 veces - 0xD5 -> 17 veces - 0xE3 -> 14 veces - -Offset 0x043E1 (17377): - Valores distintos (13): 0x0B, 0x14, 0x17, 0x20, 0x2D, 0x42, 0x47, 0x49, 0x62, 0x69, 0xC1, 0xE1, 0xF2 - Clasificación: bitfield_like - Más frecuentes: - 0x0B -> 88 veces - 0x49 -> 33 veces - 0x42 -> 30 veces - 0xE1 -> 17 veces - 0x47 -> 14 veces - -Offset 0x043E2 (17378): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x02 -> 17 veces - 0x04 -> 11 veces - 0x01 -> 8 veces - -Offset 0x043E6 (17382): - Valores distintos (4): 0x29, 0x2A, 0x33, 0x52 - Clasificación: small_state - Más frecuentes: - 0x2A -> 96 veces - 0x29 -> 88 veces - 0x52 -> 44 veces - 0x33 -> 6 veces - -Offset 0x043E7 (17383): - Valores distintos (4): 0x00, 0x36, 0x3A, 0x3F - Clasificación: small_state - Más frecuentes: - 0x36 -> 110 veces - 0x00 -> 88 veces - 0x3F -> 30 veces - 0x3A -> 6 veces - -Offset 0x043E8 (17384): - Valores distintos (6): 0x00, 0x23, 0x26, 0x2A, 0x2C, 0x2D - Clasificación: small_state - Más frecuentes: - 0x26 -> 101 veces - 0x00 -> 88 veces - 0x2A -> 19 veces - 0x2D -> 11 veces - 0x23 -> 9 veces - -Offset 0x043E9 (17385): - Valores distintos (5): 0x0A, 0x10, 0x15, 0x17, 0x1B - Clasificación: small_state - Más frecuentes: - 0x0A -> 137 veces - 0x15 -> 53 veces - 0x17 -> 19 veces - 0x10 -> 14 veces - 0x1B -> 11 veces - -Offset 0x043EA (17386): - Valores distintos (4): 0x00, 0x01, 0x0C, 0x14 - Clasificación: small_state - Más frecuentes: - 0x01 -> 137 veces - 0x00 -> 66 veces - 0x14 -> 17 veces - 0x0C -> 14 veces - -Offset 0x043EC (17388): - Valores distintos (13): 0x07, 0x1C, 0x29, 0x3F, 0x63, 0x77, 0x7F, 0x8B, 0x9F, 0xB2, 0xB8, 0xBC, 0xC8 - Clasificación: bitfield_like - Más frecuentes: - 0x63 -> 88 veces - 0xBC -> 47 veces - 0xB2 -> 30 veces - 0x29 -> 17 veces - 0x3F -> 11 veces - -Offset 0x043ED (17389): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x043EE (17390): - Valores distintos (10): 0x07, 0x09, 0x0C, 0x0D, 0x10, 0x14, 0x1E, 0x1F, 0x23, 0x24 - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 88 veces - 0x10 -> 47 veces - 0x0D -> 40 veces - 0x23 -> 17 veces - 0x14 -> 14 veces - -Offset 0x043F3 (17395): - Valores distintos (5): 0x01, 0x04, 0x0A, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 88 veces - 0x01 -> 61 veces - 0x04 -> 49 veces - 0x10 -> 30 veces - 0x0A -> 6 veces - -Offset 0x043F4 (17396): - Valores distintos (12): 0x12, 0x1C, 0x29, 0x3F, 0x63, 0x77, 0x7F, 0x8B, 0x9F, 0xB2, 0xBC, 0xC8 - Clasificación: bitfield_like - Más frecuentes: - 0x63 -> 88 veces - 0xBC -> 47 veces - 0xB2 -> 30 veces - 0x29 -> 17 veces - 0xC8 -> 14 veces - -Offset 0x043F5 (17397): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x043F6 (17398): - Valores distintos (10): 0x07, 0x09, 0x0C, 0x0D, 0x10, 0x14, 0x1E, 0x1F, 0x23, 0x24 - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 88 veces - 0x10 -> 47 veces - 0x0D -> 40 veces - 0x23 -> 17 veces - 0x14 -> 14 veces - -Offset 0x043F8 (17400): - Valores distintos (13): 0x3A, 0x42, 0x4F, 0x54, 0x66, 0x6D, 0x72, 0x7C, 0x7F, 0x84, 0x85, 0xFA, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0x54 -> 88 veces - 0x7F -> 33 veces - 0x84 -> 30 veces - 0x42 -> 17 veces - 0xFD -> 14 veces - -Offset 0x043F9 (17401): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x043FA (17402): - Valores distintos (13): 0x00, 0x04, 0x17, 0x41, 0x5A, 0x61, 0x66, 0x74, 0x82, 0x8F, 0xA8, 0xAE, 0xE8 - Clasificación: bitfield_like - Más frecuentes: - 0x41 -> 88 veces - 0xA8 -> 33 veces - 0x82 -> 30 veces - 0x04 -> 17 veces - 0x8F -> 14 veces - -Offset 0x043FB (17403): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x043FC (17404): - Valores distintos (9): 0x00, 0x02, 0x04, 0x05, 0x06, 0x08, 0x09, 0x0B, 0x1A - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 88 veces - 0x05 -> 49 veces - 0x04 -> 33 veces - 0x0B -> 17 veces - 0x00 -> 14 veces - -Offset 0x043FE (17406): - Valores distintos (7): 0x15, 0x18, 0x1F, 0x38, 0x3B, 0x3E, 0x46 - Clasificación: small_state - Más frecuentes: - 0x15 -> 137 veces - 0x18 -> 47 veces - 0x3E -> 17 veces - 0x1F -> 14 veces - 0x46 -> 11 veces - -Offset 0x04403 (17411): - Valores distintos (2): 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x04 -> 223 veces - 0x06 -> 11 veces - -Offset 0x04405 (17413): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 220 veces - 0x07 -> 14 veces - -Offset 0x04409 (17417): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 223 veces - 0x07 -> 11 veces - -Offset 0x0440C (17420): - Valores distintos (2): 0x37, 0x3C - Clasificación: small_state - Más frecuentes: - 0x37 -> 173 veces - 0x3C -> 61 veces - -Offset 0x0440E (17422): - Valores distintos (2): 0x08, 0x0B - Clasificación: small_state - Más frecuentes: - 0x08 -> 228 veces - 0x0B -> 6 veces - -Offset 0x0440F (17423): - Valores distintos (4): 0x00, 0x02, 0x04, 0x0E - Clasificación: small_state - Más frecuentes: - 0x04 -> 94 veces - 0x02 -> 61 veces - 0x00 -> 49 veces - 0x0E -> 30 veces - -Offset 0x04414 (17428): - Valores distintos (12): 0x12, 0x1C, 0x29, 0x3F, 0x63, 0x77, 0x7F, 0x8B, 0x9F, 0xB2, 0xBC, 0xC8 - Clasificación: bitfield_like - Más frecuentes: - 0x63 -> 88 veces - 0xBC -> 47 veces - 0xB2 -> 30 veces - 0x29 -> 17 veces - 0xC8 -> 14 veces - -Offset 0x04415 (17429): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x04416 (17430): - Valores distintos (10): 0x07, 0x09, 0x0C, 0x0D, 0x10, 0x14, 0x1E, 0x1F, 0x23, 0x24 - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 88 veces - 0x10 -> 47 veces - 0x0D -> 40 veces - 0x23 -> 17 veces - 0x14 -> 14 veces - -Offset 0x04418 (17432): - Valores distintos (12): 0x3A, 0x44, 0x4B, 0x50, 0x5A, 0x62, 0x67, 0x6D, 0x9D, 0xA4, 0xAC, 0xB9 - Clasificación: bitfield_like - Más frecuentes: - 0x3A -> 88 veces - 0x67 -> 47 veces - 0x62 -> 30 veces - 0xAC -> 17 veces - 0x6D -> 14 veces - -Offset 0x0441A (17434): - Valores distintos (12): 0x2C, 0x36, 0x3D, 0x42, 0x4D, 0x5B, 0x5D, 0x63, 0x82, 0x87, 0x8B, 0x93 - Clasificación: bitfield_like - Más frecuentes: - 0x2C -> 88 veces - 0x5D -> 47 veces - 0x5B -> 30 veces - 0x8B -> 17 veces - 0x63 -> 14 veces - -Offset 0x0441C (17436): - Valores distintos (7): 0x11, 0x12, 0x14, 0x18, 0x1D, 0x26, 0x35 - Clasificación: small_state - Más frecuentes: - 0x11 -> 137 veces - 0x12 -> 47 veces - 0x26 -> 17 veces - 0x14 -> 14 veces - 0x35 -> 11 veces - -Offset 0x0441E (17438): - Valores distintos (7): 0x15, 0x18, 0x1F, 0x38, 0x3B, 0x3E, 0x46 - Clasificación: small_state - Más frecuentes: - 0x15 -> 137 veces - 0x18 -> 47 veces - 0x3E -> 17 veces - 0x1F -> 14 veces - 0x46 -> 11 veces - -Offset 0x0444A (17482): - Valores distintos (2): 0x00, 0x5C - Clasificación: small_state - Más frecuentes: - 0x5C -> 146 veces - 0x00 -> 88 veces - -Offset 0x0444B (17483): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 127 veces - 0x00 -> 107 veces - -Offset 0x0444C (17484): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x69 -> 36 veces - -Offset 0x0444D (17485): - Valores distintos (2): 0x00, 0x5D - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x5D -> 36 veces - -Offset 0x04452 (17490): - Valores distintos (3): 0x00, 0x0F, 0x26 - Clasificación: small_state - Más frecuentes: - 0x0F -> 116 veces - 0x00 -> 107 veces - 0x26 -> 11 veces - -Offset 0x04453 (17491): - Valores distintos (2): 0x00, 0x1A - Clasificación: small_state - Más frecuentes: - 0x1A -> 127 veces - 0x00 -> 107 veces - -Offset 0x04454 (17492): - Valores distintos (2): 0x00, 0x99 - Clasificación: small_state - Más frecuentes: - 0x99 -> 127 veces - 0x00 -> 107 veces - -Offset 0x04455 (17493): - Valores distintos (2): 0x00, 0xC4 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0xC4 -> 25 veces - -Offset 0x04456 (17494): - Valores distintos (2): 0x00, 0xA3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0xA3 -> 25 veces - -Offset 0x04457 (17495): - Valores distintos (2): 0x00, 0xAC - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0xAC -> 36 veces - -Offset 0x04458 (17496): - Valores distintos (2): 0x00, 0xCB - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0xCB -> 36 veces - -Offset 0x04459 (17497): - Valores distintos (2): 0x00, 0x9A - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x9A -> 30 veces - -Offset 0x0445A (17498): - Valores distintos (2): 0x00, 0x9D - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x9D -> 30 veces - -Offset 0x0445B (17499): - Valores distintos (2): 0x00, 0xAB - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xAB -> 11 veces - -Offset 0x0445C (17500): - Valores distintos (5): 0x00, 0x0D, 0x15, 0x1E, 0x22 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x15 -> 61 veces - 0x0D -> 49 veces - 0x22 -> 30 veces - 0x1E -> 6 veces - -Offset 0x0445D (17501): - Valores distintos (4): 0x00, 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0x04 -> 49 veces - 0xFF -> 30 veces - 0x02 -> 6 veces - -Offset 0x0445E (17502): - Valores distintos (3): 0x00, 0x01, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 167 veces - 0x01 -> 61 veces - 0xFE -> 6 veces - -Offset 0x0445F (17503): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 91 veces - 0x00 -> 88 veces - 0x01 -> 49 veces - 0x02 -> 6 veces - -Offset 0x04460 (17504): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 91 veces - 0x00 -> 88 veces - 0x03 -> 49 veces - 0x01 -> 6 veces - -Offset 0x04461 (17505): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 149 veces - 0xFD -> 49 veces - 0x02 -> 30 veces - 0xFF -> 6 veces - -Offset 0x04462 (17506): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 118 veces - 0x02 -> 61 veces - 0xFD -> 49 veces - 0xFF -> 6 veces - -Offset 0x04482 (17538): - Valores distintos (4): 0x03, 0x04, 0x06, 0x09 - Clasificación: small_state - Más frecuentes: - 0x09 -> 205 veces - 0x06 -> 21 veces - 0x03 -> 6 veces - 0x04 -> 2 veces - -Offset 0x04483 (17539): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 205 veces - 0x01 -> 29 veces - -Offset 0x04484 (17540): - Valores distintos (5): 0x0D, 0x21, 0x46, 0x81, 0xBD - Clasificación: small_state - Más frecuentes: - 0x81 -> 205 veces - 0x0D -> 18 veces - 0x21 -> 6 veces - 0xBD -> 3 veces - 0x46 -> 2 veces - -Offset 0x04485 (17541): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 205 veces - 0x01 -> 18 veces - 0x00 -> 11 veces - -Offset 0x04489 (17545): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 230 veces - 0x20 -> 4 veces - -Offset 0x0448A (17546): - Valores distintos (2): 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 228 veces - 0x01 -> 6 veces - -Offset 0x0448B (17547): - Valores distintos (3): 0x00, 0x32, 0x33 - Clasificación: small_state - Más frecuentes: - 0x33 -> 205 veces - 0x32 -> 23 veces - 0x00 -> 6 veces - -Offset 0x0448C (17548): - Valores distintos (3): 0x00, 0x21, 0x23 - Clasificación: small_state - Más frecuentes: - 0x23 -> 205 veces - 0x21 -> 23 veces - 0x00 -> 6 veces - -Offset 0x0448D (17549): - Valores distintos (2): 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 226 veces - 0x01 -> 8 veces - -Offset 0x04490 (17552): - Valores distintos (7): 0x01, 0x10, 0x1B, 0x29, 0x2E, 0x31, 0x36 - Clasificación: small_state - Más frecuentes: - 0x36 -> 185 veces - 0x29 -> 21 veces - 0x31 -> 15 veces - 0x10 -> 6 veces - 0x01 -> 4 veces - -Offset 0x04492 (17554): - Valores distintos (4): 0x0D, 0x0F, 0x18, 0x23 - Clasificación: small_state - Más frecuentes: - 0x23 -> 205 veces - 0x18 -> 21 veces - 0x0D -> 6 veces - 0x0F -> 2 veces - -Offset 0x04496 (17558): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 219 veces - 0x01 -> 15 veces - -Offset 0x04498 (17560): - Valores distintos (5): 0x1B, 0x1F, 0x29, 0x31, 0x36 - Clasificación: small_state - Más frecuentes: - 0x36 -> 190 veces - 0x29 -> 21 veces - 0x31 -> 15 veces - 0x1B -> 6 veces - 0x1F -> 2 veces - -Offset 0x0449A (17562): - Valores distintos (4): 0x0F, 0x13, 0x18, 0x23 - Clasificación: small_state - Más frecuentes: - 0x23 -> 205 veces - 0x18 -> 21 veces - 0x0F -> 6 veces - 0x13 -> 2 veces - -Offset 0x0449C (17564): - Valores distintos (4): 0x14, 0x18, 0x1B, 0x24 - Clasificación: small_state - Más frecuentes: - 0x24 -> 205 veces - 0x1B -> 21 veces - 0x14 -> 6 veces - 0x18 -> 2 veces - -Offset 0x0449E (17566): - Valores distintos (4): 0x0D, 0x11, 0x16, 0x22 - Clasificación: small_state - Más frecuentes: - 0x22 -> 205 veces - 0x16 -> 21 veces - 0x0D -> 6 veces - 0x11 -> 2 veces - -Offset 0x044A0 (17568): - Valores distintos (3): 0x07, 0x08, 0x09 - Clasificación: small_state - Más frecuentes: - 0x08 -> 207 veces - 0x09 -> 21 veces - 0x07 -> 6 veces - -Offset 0x044A2 (17570): - Valores distintos (4): 0x0F, 0x13, 0x18, 0x21 - Clasificación: small_state - Más frecuentes: - 0x21 -> 205 veces - 0x18 -> 21 veces - 0x0F -> 6 veces - 0x13 -> 2 veces - -Offset 0x044B8 (17592): - Valores distintos (4): 0x1B, 0x1F, 0x29, 0x36 - Clasificación: small_state - Más frecuentes: - 0x36 -> 205 veces - 0x29 -> 21 veces - 0x1B -> 6 veces - 0x1F -> 2 veces - -Offset 0x044BA (17594): - Valores distintos (4): 0x0F, 0x13, 0x18, 0x23 - Clasificación: small_state - Más frecuentes: - 0x23 -> 205 veces - 0x18 -> 21 veces - 0x0F -> 6 veces - 0x13 -> 2 veces - -Offset 0x044BC (17596): - Valores distintos (4): 0x10, 0x12, 0x15, 0x1E - Clasificación: small_state - Más frecuentes: - 0x1E -> 205 veces - 0x15 -> 21 veces - 0x10 -> 6 veces - 0x12 -> 2 veces - -Offset 0x044BE (17598): - Valores distintos (4): 0x0B, 0x0D, 0x10, 0x18 - Clasificación: small_state - Más frecuentes: - 0x18 -> 205 veces - 0x10 -> 21 veces - 0x0B -> 6 veces - 0x0D -> 2 veces - -Offset 0x044C0 (17600): - Valores distintos (4): 0x0B, 0x0C, 0x0E, 0x0F - Clasificación: small_state - Más frecuentes: - 0x0F -> 205 veces - 0x0E -> 21 veces - 0x0B -> 6 veces - 0x0C -> 2 veces - -Offset 0x044C2 (17602): - Valores distintos (4): 0x0F, 0x13, 0x18, 0x21 - Clasificación: small_state - Más frecuentes: - 0x21 -> 205 veces - 0x18 -> 21 veces - 0x0F -> 6 veces - 0x13 -> 2 veces - -Offset 0x044ED (17645): - Valores distintos (2): 0x00, 0x5E - Clasificación: small_state - Más frecuentes: - 0x5E -> 228 veces - 0x00 -> 6 veces - -Offset 0x044EE (17646): - Valores distintos (2): 0x00, 0x67 - Clasificación: small_state - Más frecuentes: - 0x67 -> 205 veces - 0x00 -> 29 veces - -Offset 0x04526 (17702): - Valores distintos (16): 0x05, 0x06, 0x07, 0x09, 0x14, 0x16, 0x17, 0x18, 0x19, 0x1F, 0x21, 0x22, 0x23, 0x29, 0x2B, 0x2F - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 78 veces - 0x19 -> 28 veces - 0x16 -> 25 veces - 0x07 -> 21 veces - 0x2B -> 17 veces - -Offset 0x04527 (17703): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 156 veces - 0x00 -> 78 veces - -Offset 0x04528 (17704): - Valores distintos (17): 0x0E, 0x17, 0x18, 0x1B, 0x21, 0x4C, 0x5D, 0x73, 0x7B, 0x93, 0x95, 0xA0, 0xB1, 0xCD, 0xD3, 0xE0, 0xF5 - Clasificación: bitfield_like - Más frecuentes: - 0x7B -> 90 veces - 0xE0 -> 28 veces - 0x1B -> 25 veces - 0x21 -> 18 veces - 0x4C -> 17 veces - -Offset 0x04529 (17705): - Valores distintos (16): 0x00, 0x01, 0x02, 0x19, 0x26, 0x2E, 0x3A, 0x41, 0x49, 0x4C, 0x51, 0x5E, 0x80, 0xCF, 0xD2, 0xD9 - Clasificación: bitfield_like - Más frecuentes: - 0x02 -> 82 veces - 0x5E -> 28 veces - 0x3A -> 25 veces - 0x01 -> 21 veces - 0x80 -> 17 veces - -Offset 0x0452A (17706): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 185 veces - 0x01 -> 19 veces - 0x03 -> 17 veces - 0x06 -> 7 veces - 0x05 -> 4 veces - -Offset 0x0452E (17710): - Valores distintos (7): 0x02, 0x04, 0x07, 0x09, 0x0E, 0x12, 0x43 - Clasificación: small_state - Más frecuentes: - 0x04 -> 78 veces - 0x09 -> 39 veces - 0x0E -> 33 veces - 0x43 -> 30 veces - 0x02 -> 29 veces - -Offset 0x0452F (17711): - Valores distintos (7): 0x00, 0x32, 0x33, 0x38, 0x3B, 0x3C, 0x40 - Clasificación: small_state - Más frecuentes: - 0x33 -> 78 veces - 0x3B -> 67 veces - 0x38 -> 30 veces - 0x32 -> 29 veces - 0x00 -> 14 veces - -Offset 0x04530 (17712): - Valores distintos (7): 0x00, 0x21, 0x23, 0x26, 0x27, 0x2A, 0x2D - Clasificación: small_state - Más frecuentes: - 0x23 -> 99 veces - 0x2A -> 69 veces - 0x26 -> 25 veces - 0x00 -> 20 veces - 0x2D -> 11 veces - -Offset 0x04531 (17713): - Valores distintos (6): 0x00, 0x02, 0x0E, 0x10, 0x14, 0x1A - Clasificación: small_state - Más frecuentes: - 0x02 -> 107 veces - 0x1A -> 45 veces - 0x14 -> 38 veces - 0x10 -> 25 veces - 0x00 -> 14 veces - -Offset 0x04532 (17714): - Valores distintos (3): 0x00, 0x04, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x04 -> 39 veces - 0x0C -> 11 veces - -Offset 0x04533 (17715): - Valores distintos (3): 0x00, 0x02, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x02 -> 39 veces - 0x0B -> 11 veces - -Offset 0x04534 (17716): - Valores distintos (13): 0x25, 0x30, 0x33, 0x38, 0x3E, 0x6F, 0x7C, 0x84, 0x8D, 0x93, 0x95, 0x96, 0xA1 - Clasificación: bitfield_like - Más frecuentes: - 0x3E -> 63 veces - 0xA1 -> 34 veces - 0x93 -> 32 veces - 0x7C -> 25 veces - 0x30 -> 18 veces - -Offset 0x04536 (17718): - Valores distintos (7): 0x0C, 0x0D, 0x12, 0x23, 0x24, 0x26, 0x27 - Clasificación: small_state - Más frecuentes: - 0x27 -> 83 veces - 0x12 -> 78 veces - 0x24 -> 25 veces - 0x0D -> 21 veces - 0x26 -> 14 veces - -Offset 0x04538 (17720): - Valores distintos (2): 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 219 veces - 0x01 -> 15 veces - -Offset 0x0453A (17722): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 219 veces - 0x01 -> 15 veces - -Offset 0x0453B (17723): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 112 veces - 0x00 -> 72 veces - 0x0F -> 50 veces - -Offset 0x0453C (17724): - Valores distintos (11): 0x2A, 0x2E, 0x33, 0x38, 0x3E, 0x6F, 0x7C, 0x84, 0x8D, 0x93, 0xA1 - Clasificación: bitfield_like - Más frecuentes: - 0x3E -> 63 veces - 0xA1 -> 50 veces - 0x93 -> 28 veces - 0x7C -> 25 veces - 0x33 -> 21 veces - -Offset 0x0453E (17726): - Valores distintos (7): 0x0C, 0x0D, 0x12, 0x23, 0x24, 0x26, 0x27 - Clasificación: small_state - Más frecuentes: - 0x27 -> 83 veces - 0x12 -> 78 veces - 0x24 -> 25 veces - 0x0D -> 23 veces - 0x26 -> 14 veces - -Offset 0x04540 (17728): - Valores distintos (16): 0x00, 0x11, 0x1D, 0x20, 0x24, 0x32, 0x62, 0x74, 0x78, 0x97, 0x9D, 0xD5, 0xDF, 0xE1, 0xE4, 0xF9 - Clasificación: bitfield_like - Más frecuentes: - 0x32 -> 78 veces - 0x9D -> 28 veces - 0x74 -> 25 veces - 0x24 -> 21 veces - 0x00 -> 17 veces - -Offset 0x04541 (17729): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 206 veces - 0x01 -> 28 veces - -Offset 0x04542 (17730): - Valores distintos (17): 0x04, 0x14, 0x17, 0x1B, 0x1C, 0x23, 0x39, 0x56, 0x72, 0x99, 0x9F, 0xA3, 0xBF, 0xC6, 0xDE, 0xE3, 0xFB - Clasificación: bitfield_like - Más frecuentes: - 0x23 -> 78 veces - 0xA3 -> 28 veces - 0x72 -> 25 veces - 0x1C -> 21 veces - 0x04 -> 17 veces - -Offset 0x04543 (17731): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 206 veces - 0x01 -> 28 veces - -Offset 0x04544 (17732): - Valores distintos (15): 0x0E, 0x0F, 0x10, 0x1D, 0x1E, 0x20, 0x21, 0x25, 0x2D, 0x31, 0x33, 0x35, 0x45, 0x4B, 0x55 - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 84 veces - 0x20 -> 28 veces - 0x1D -> 25 veces - 0x10 -> 21 veces - 0x4B -> 17 veces - -Offset 0x04546 (17734): - Valores distintos (12): 0x16, 0x19, 0x1E, 0x35, 0x36, 0x64, 0x6B, 0x71, 0x75, 0x8A, 0x8D, 0x94 - Clasificación: bitfield_like - Más frecuentes: - 0x1E -> 78 veces - 0x35 -> 49 veces - 0x36 -> 28 veces - 0x19 -> 23 veces - 0x94 -> 17 veces - -Offset 0x0454B (17739): - Valores distintos (3): 0x02, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 184 veces - 0x05 -> 39 veces - 0x07 -> 11 veces - -Offset 0x0454C (17740): - Valores distintos (3): 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x02 -> 162 veces - 0x04 -> 39 veces - 0x06 -> 33 veces - -Offset 0x0454D (17741): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 223 veces - 0x07 -> 11 veces - -Offset 0x04551 (17745): - Valores distintos (2): 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x02 -> 223 veces - 0x04 -> 11 veces - -Offset 0x04552 (17746): - Valores distintos (2): 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x02 -> 184 veces - 0x03 -> 50 veces - -Offset 0x04553 (17747): - Valores distintos (2): 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x02 -> 184 veces - 0x03 -> 50 veces - -Offset 0x04556 (17750): - Valores distintos (2): 0x05, 0x0D - Clasificación: small_state - Más frecuentes: - 0x05 -> 204 veces - 0x0D -> 30 veces - -Offset 0x0455C (17756): - Valores distintos (10): 0x2A, 0x2E, 0x33, 0x3E, 0x6F, 0x7C, 0x84, 0x8D, 0x93, 0xA1 - Clasificación: bitfield_like - Más frecuentes: - 0x3E -> 78 veces - 0xA1 -> 50 veces - 0x93 -> 28 veces - 0x7C -> 25 veces - 0x33 -> 21 veces - -Offset 0x0455E (17758): - Valores distintos (7): 0x0C, 0x0D, 0x12, 0x23, 0x24, 0x26, 0x27 - Clasificación: small_state - Más frecuentes: - 0x27 -> 83 veces - 0x12 -> 78 veces - 0x24 -> 25 veces - 0x0D -> 23 veces - 0x26 -> 14 veces - -Offset 0x04560 (17760): - Valores distintos (16): 0x17, 0x1A, 0x1E, 0x23, 0x42, 0x4E, 0x52, 0x54, 0x5A, 0x75, 0x81, 0x84, 0x89, 0xA4, 0xAB, 0xBC - Clasificación: bitfield_like - Más frecuentes: - 0x23 -> 78 veces - 0x5A -> 28 veces - 0x4E -> 25 veces - 0x1E -> 21 veces - 0xAB -> 17 veces - -Offset 0x04562 (17762): - Valores distintos (16): 0x0F, 0x11, 0x14, 0x19, 0x30, 0x37, 0x39, 0x3E, 0x42, 0x59, 0x60, 0x63, 0x68, 0x80, 0x89, 0x9B - Clasificación: bitfield_like - Más frecuentes: - 0x19 -> 78 veces - 0x42 -> 28 veces - 0x37 -> 25 veces - 0x14 -> 21 veces - 0x89 -> 17 veces - -Offset 0x04564 (17764): - Valores distintos (15): 0x13, 0x14, 0x16, 0x17, 0x27, 0x29, 0x2C, 0x2E, 0x3B, 0x3F, 0x43, 0x45, 0x52, 0x58, 0x62 - Clasificación: bitfield_like - Más frecuentes: - 0x17 -> 78 veces - 0x29 -> 39 veces - 0x2E -> 28 veces - 0x16 -> 21 veces - 0x58 -> 17 veces - -Offset 0x04566 (17766): - Valores distintos (12): 0x16, 0x19, 0x1E, 0x35, 0x36, 0x46, 0x4D, 0x53, 0x57, 0x6F, 0x76, 0x85 - Clasificación: bitfield_like - Más frecuentes: - 0x1E -> 78 veces - 0x35 -> 49 veces - 0x36 -> 28 veces - 0x19 -> 23 veces - 0x76 -> 17 veces - -Offset 0x04586 (17798): - Valores distintos (2): 0x00, 0x58 - Clasificación: small_state - Más frecuentes: - 0x58 -> 127 veces - 0x00 -> 107 veces - -Offset 0x04587 (17799): - Valores distintos (2): 0x00, 0x57 - Clasificación: small_state - Más frecuentes: - 0x57 -> 127 veces - 0x00 -> 107 veces - -Offset 0x04588 (17800): - Valores distintos (2): 0x00, 0x54 - Clasificación: small_state - Más frecuentes: - 0x54 -> 127 veces - 0x00 -> 107 veces - -Offset 0x04591 (17809): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x61 -> 205 veces - 0x00 -> 29 veces - -Offset 0x04592 (17810): - Valores distintos (2): 0x00, 0x62 - Clasificación: small_state - Más frecuentes: - 0x62 -> 127 veces - 0x00 -> 107 veces - -Offset 0x04593 (17811): - Valores distintos (2): 0x00, 0x40 - Clasificación: small_state - Más frecuentes: - 0x40 -> 127 veces - 0x00 -> 107 veces - -Offset 0x04594 (17812): - Valores distintos (2): 0x00, 0x6A - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x6A -> 50 veces - -Offset 0x04595 (17813): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x63 -> 30 veces - -Offset 0x0459A (17818): - Valores distintos (2): 0x00, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x16 -> 50 veces - -Offset 0x0459B (17819): - Valores distintos (2): 0x00, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x2A -> 50 veces - -Offset 0x0459C (17820): - Valores distintos (2): 0x00, 0x9C - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x9C -> 11 veces - -Offset 0x0459D (17821): - Valores distintos (2): 0x00, 0x2B - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x2B -> 11 veces - -Offset 0x0459E (17822): - Valores distintos (2): 0x00, 0x13 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x13 -> 11 veces - -Offset 0x045A4 (17828): - Valores distintos (3): 0x00, 0x14, 0x1B - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0x14 -> 72 veces - 0x1B -> 50 veces - -Offset 0x045A5 (17829): - Valores distintos (3): 0x00, 0x02, 0xFA - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0x02 -> 72 veces - 0xFA -> 50 veces - -Offset 0x045A6 (17830): - Valores distintos (3): 0x00, 0xFA, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0xFE -> 72 veces - 0xFA -> 50 veces - -Offset 0x045A7 (17831): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 122 veces - 0x00 -> 112 veces - -Offset 0x045A8 (17832): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0x01 -> 72 veces - 0x02 -> 50 veces - -Offset 0x045A9 (17833): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 50 veces - -Offset 0x045AA (17834): - Valores distintos (3): 0x00, 0x02, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0xFD -> 72 veces - 0x02 -> 50 veces - -Offset 0x045CA (17866): - Valores distintos (19): 0x0A, 0x0D, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x15, 0x16, 0x19, 0x1A, 0x1B, 0x1E, 0x21, 0x22, 0x23, 0x24, 0x2A, 0x2D - Clasificación: bitfield_like - Más frecuentes: - 0x0A -> 51 veces - 0x15 -> 25 veces - 0x0F -> 22 veces - 0x2A -> 19 veces - 0x1E -> 16 veces - -Offset 0x045CB (17867): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 166 veces - 0x00 -> 68 veces - -Offset 0x045CC (17868): - Valores distintos (23): 0x03, 0x16, 0x2E, 0x30, 0x33, 0x52, 0x53, 0x59, 0x7B, 0x81, 0x93, 0x9E, 0xAB, 0xB3, 0xBF, 0xCC, 0xDB, 0xE8, 0xEA, 0xEE, 0xF4, 0xF6, 0xF8 - Clasificación: bitfield_like - Más frecuentes: - 0xE8 -> 61 veces - 0x59 -> 25 veces - 0xF6 -> 20 veces - 0x93 -> 19 veces - 0xAB -> 15 veces - -Offset 0x045CD (17869): - Valores distintos (23): 0x03, 0x04, 0x09, 0x0C, 0x0F, 0x10, 0x15, 0x18, 0x19, 0x22, 0x28, 0x33, 0x35, 0x43, 0x48, 0x5F, 0x63, 0x6C, 0x70, 0x7C, 0x90, 0xB8, 0xCD - Clasificación: bitfield_like - Más frecuentes: - 0x03 -> 45 veces - 0x35 -> 25 veces - 0x10 -> 21 veces - 0x33 -> 19 veces - 0xB8 -> 16 veces - -Offset 0x045CE (17870): - Valores distintos (5): 0x00, 0x01, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 20 veces - 0x03 -> 19 veces - 0x05 -> 7 veces - 0x04 -> 4 veces - -Offset 0x045D1 (17873): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 227 veces - 0x20 -> 7 veces - -Offset 0x045D2 (17874): - Valores distintos (7): 0x46, 0x49, 0x4A, 0x4B, 0x4C, 0x4E, 0x50 - Clasificación: small_state - Más frecuentes: - 0x46 -> 94 veces - 0x4A -> 44 veces - 0x4C -> 28 veces - 0x4E -> 20 veces - 0x4B -> 19 veces - -Offset 0x045D3 (17875): - Valores distintos (5): 0x00, 0x32, 0x36, 0x3C, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x36 -> 57 veces - 0x3C -> 50 veces - 0x3E -> 33 veces - 0x32 -> 6 veces - -Offset 0x045D4 (17876): - Valores distintos (4): 0x26, 0x29, 0x2B, 0x2F - Clasificación: small_state - Más frecuentes: - 0x26 -> 137 veces - 0x2B -> 55 veces - 0x29 -> 31 veces - 0x2F -> 11 veces - -Offset 0x045D5 (17877): - Valores distintos (6): 0x06, 0x08, 0x10, 0x12, 0x16, 0x18 - Clasificación: small_state - Más frecuentes: - 0x08 -> 61 veces - 0x06 -> 51 veces - 0x10 -> 39 veces - 0x18 -> 36 veces - 0x12 -> 33 veces - -Offset 0x045D6 (17878): - Valores distintos (3): 0x00, 0x02, 0x0B - Clasificación: small_state - Más frecuentes: - 0x02 -> 133 veces - 0x00 -> 51 veces - 0x0B -> 50 veces - -Offset 0x045D7 (17879): - Valores distintos (7): 0x00, 0x01, 0x09, 0x0A, 0x0B, 0x0C, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 70 veces - 0x09 -> 43 veces - 0x0B -> 43 veces - 0x0A -> 33 veces - 0x0C -> 20 veces - -Offset 0x045D8 (17880): - Valores distintos (20): 0x01, 0x17, 0x34, 0x44, 0x49, 0x4E, 0x4F, 0x50, 0x56, 0x5A, 0x60, 0x65, 0x6B, 0x71, 0x76, 0x8E, 0xA4, 0xAD, 0xB9, 0xBA - Clasificación: bitfield_like - Más frecuentes: - 0x34 -> 51 veces - 0x60 -> 25 veces - 0x49 -> 22 veces - 0xBA -> 19 veces - 0x8E -> 16 veces - -Offset 0x045DA (17882): - Valores distintos (19): 0x24, 0x28, 0x38, 0x3C, 0x3E, 0x43, 0x49, 0x4D, 0x4E, 0x4F, 0x5A, 0x5C, 0x68, 0x6C, 0x78, 0x7B, 0x99, 0x9F, 0xAB - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 51 veces - 0x4E -> 25 veces - 0x38 -> 22 veces - 0x99 -> 19 veces - 0x4D -> 16 veces - -Offset 0x045DC (17884): - Valores distintos (3): 0x01, 0x03, 0x06 - Clasificación: small_state - Más frecuentes: - 0x06 -> 209 veces - 0x01 -> 22 veces - 0x03 -> 3 veces - -Offset 0x045DE (17886): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 227 veces - 0x01 -> 7 veces - -Offset 0x045DF (17887): - Valores distintos (6): 0x03, 0x09, 0x0B, 0x0C, 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 112 veces - 0x03 -> 39 veces - 0x09 -> 36 veces - 0x0B -> 17 veces - 0x0D -> 16 veces - -Offset 0x045E0 (17888): - Valores distintos (20): 0x34, 0x41, 0x49, 0x4E, 0x50, 0x56, 0x5A, 0x60, 0x65, 0x71, 0x76, 0x7C, 0x8E, 0x9B, 0x9F, 0xA4, 0xAC, 0xAD, 0xBA, 0xBF - Clasificación: bitfield_like - Más frecuentes: - 0x34 -> 51 veces - 0x60 -> 25 veces - 0x49 -> 22 veces - 0xBA -> 19 veces - 0x8E -> 16 veces - -Offset 0x045E2 (17890): - Valores distintos (19): 0x28, 0x30, 0x38, 0x3C, 0x3E, 0x43, 0x49, 0x4E, 0x4F, 0x5A, 0x5C, 0x5D, 0x69, 0x70, 0x74, 0x78, 0x7B, 0x99, 0xAB - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 51 veces - 0x4E -> 25 veces - 0x38 -> 22 veces - 0x99 -> 19 veces - 0x69 -> 16 veces - -Offset 0x045E4 (17892): - Valores distintos (18): 0x0A, 0x0F, 0x10, 0x2F, 0x58, 0x5B, 0x5F, 0x65, 0x67, 0x6A, 0x7F, 0x83, 0x8C, 0x9B, 0x9E, 0xB2, 0xB5, 0xBE - Clasificación: bitfield_like - Más frecuentes: - 0x58 -> 51 veces - 0x8C -> 25 veces - 0x65 -> 22 veces - 0x2F -> 19 veces - 0xBE -> 16 veces - -Offset 0x045E5 (17893): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 50 veces - -Offset 0x045E6 (17894): - Valores distintos (18): 0x28, 0x38, 0x3C, 0x40, 0x4D, 0x4E, 0x64, 0x6C, 0x86, 0x87, 0x88, 0x93, 0xA7, 0xAB, 0xAD, 0xBB, 0xBD, 0xC2 - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 51 veces - 0x64 -> 25 veces - 0x3C -> 22 veces - 0xBD -> 19 veces - 0x93 -> 16 veces - -Offset 0x045E8 (17896): - Valores distintos (14): 0x0A, 0x0B, 0x0D, 0x0E, 0x0F, 0x13, 0x19, 0x1B, 0x1D, 0x21, 0x22, 0x24, 0x30, 0x38 - Clasificación: bitfield_like - Más frecuentes: - 0x0A -> 51 veces - 0x0E -> 38 veces - 0x0F -> 30 veces - 0x30 -> 19 veces - 0x1D -> 16 veces - -Offset 0x045EA (17898): - Valores distintos (19): 0x32, 0x3C, 0x3F, 0x45, 0x49, 0x4F, 0x54, 0x5F, 0x61, 0x71, 0x76, 0x79, 0x88, 0xA0, 0xA4, 0xA9, 0xAB, 0xCF, 0xE3 - Clasificación: bitfield_like - Más frecuentes: - 0x32 -> 51 veces - 0x5F -> 25 veces - 0x3F -> 22 veces - 0xCF -> 19 veces - 0x88 -> 16 veces - -Offset 0x045EF (17903): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 141 veces - 0x07 -> 93 veces - -Offset 0x045F0 (17904): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 201 veces - 0x07 -> 33 veces - -Offset 0x045F1 (17905): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 214 veces - 0x07 -> 20 veces - -Offset 0x045F5 (17909): - Valores distintos (3): 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x02 -> 198 veces - 0x04 -> 25 veces - 0x06 -> 11 veces - -Offset 0x045F6 (17910): - Valores distintos (3): 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x02 -> 165 veces - 0x04 -> 58 veces - 0x06 -> 11 veces - -Offset 0x045F7 (17911): - Valores distintos (3): 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x02 -> 198 veces - 0x04 -> 25 veces - 0x06 -> 11 veces - -Offset 0x045F8 (17912): - Valores distintos (2): 0x1E, 0x28 - Clasificación: small_state - Más frecuentes: - 0x1E -> 195 veces - 0x28 -> 39 veces - -Offset 0x045FB (17915): - Valores distintos (2): 0x04, 0x09 - Clasificación: small_state - Más frecuentes: - 0x04 -> 195 veces - 0x09 -> 39 veces - -Offset 0x045FC (17916): - Valores distintos (2): 0x46, 0x4B - Clasificación: small_state - Más frecuentes: - 0x46 -> 195 veces - 0x4B -> 39 veces - -Offset 0x04600 (17920): - Valores distintos (19): 0x34, 0x41, 0x49, 0x4E, 0x50, 0x56, 0x5A, 0x60, 0x65, 0x71, 0x76, 0x7C, 0x8E, 0x9B, 0x9F, 0xA4, 0xAD, 0xBA, 0xBF - Clasificación: bitfield_like - Más frecuentes: - 0x34 -> 51 veces - 0x60 -> 25 veces - 0x49 -> 22 veces - 0xBA -> 19 veces - 0x8E -> 16 veces - -Offset 0x04602 (17922): - Valores distintos (19): 0x28, 0x30, 0x38, 0x3C, 0x3E, 0x43, 0x49, 0x4E, 0x4F, 0x5A, 0x5C, 0x5D, 0x69, 0x70, 0x74, 0x78, 0x7B, 0x99, 0xAB - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 51 veces - 0x4E -> 25 veces - 0x38 -> 22 veces - 0x99 -> 19 veces - 0x69 -> 16 veces - -Offset 0x04604 (17924): - Valores distintos (18): 0x1E, 0x25, 0x2B, 0x2D, 0x30, 0x31, 0x35, 0x3C, 0x41, 0x4E, 0x52, 0x55, 0x5E, 0x67, 0x6C, 0x6D, 0x84, 0x90 - Clasificación: bitfield_like - Más frecuentes: - 0x1E -> 51 veces - 0x3C -> 25 veces - 0x2B -> 22 veces - 0x84 -> 19 veces - 0x5E -> 16 veces - -Offset 0x04606 (17926): - Valores distintos (16): 0x19, 0x1D, 0x21, 0x24, 0x26, 0x27, 0x2D, 0x36, 0x37, 0x38, 0x3F, 0x44, 0x48, 0x4A, 0x4F, 0x51 - Clasificación: bitfield_like - Más frecuentes: - 0x19 -> 51 veces - 0x2D -> 39 veces - 0x51 -> 30 veces - 0x21 -> 22 veces - 0x3F -> 16 veces - -Offset 0x04608 (17928): - Valores distintos (15): 0x0F, 0x11, 0x14, 0x15, 0x16, 0x19, 0x1C, 0x1F, 0x21, 0x24, 0x27, 0x28, 0x2A, 0x36, 0x3E - Clasificación: bitfield_like - Más frecuentes: - 0x0F -> 51 veces - 0x19 -> 25 veces - 0x14 -> 23 veces - 0x36 -> 19 veces - 0x24 -> 16 veces - -Offset 0x0460A (17930): - Valores distintos (19): 0x32, 0x3C, 0x3F, 0x45, 0x49, 0x4F, 0x54, 0x5F, 0x61, 0x71, 0x76, 0x79, 0x88, 0x9B, 0x9F, 0xA6, 0xA9, 0xCF, 0xE3 - Clasificación: bitfield_like - Más frecuentes: - 0x32 -> 51 veces - 0x5F -> 25 veces - 0x3F -> 22 veces - 0xCF -> 19 veces - 0x88 -> 16 veces - -Offset 0x04622 (17954): - Valores distintos (2): 0x00, 0x47 - Clasificación: small_state - Más frecuentes: - 0x47 -> 137 veces - 0x00 -> 97 veces - -Offset 0x04623 (17955): - Valores distintos (2): 0x00, 0x73 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x73 -> 83 veces - -Offset 0x04624 (17956): - Valores distintos (2): 0x00, 0x4C - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x4C -> 76 veces - -Offset 0x04625 (17957): - Valores distintos (2): 0x00, 0x49 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x49 -> 50 veces - -Offset 0x04626 (17958): - Valores distintos (2): 0x00, 0x48 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x48 -> 36 veces - -Offset 0x0462E (17966): - Valores distintos (2): 0x00, 0x6B - Clasificación: small_state - Más frecuentes: - 0x6B -> 183 veces - 0x00 -> 51 veces - -Offset 0x0462F (17967): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x6C -> 168 veces - 0x00 -> 66 veces - -Offset 0x04630 (17968): - Valores distintos (2): 0x00, 0x54 - Clasificación: small_state - Más frecuentes: - 0x54 -> 145 veces - 0x00 -> 89 veces - -Offset 0x04631 (17969): - Valores distintos (2): 0x00, 0x55 - Clasificación: small_state - Más frecuentes: - 0x55 -> 122 veces - 0x00 -> 112 veces - -Offset 0x04634 (17972): - Valores distintos (2): 0x00, 0x66 - Clasificación: small_state - Más frecuentes: - 0x66 -> 183 veces - 0x00 -> 51 veces - -Offset 0x04635 (17973): - Valores distintos (2): 0x00, 0x6E - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x6E -> 66 veces - -Offset 0x0463E (17982): - Valores distintos (2): 0x00, 0xA6 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xA6 -> 83 veces - -Offset 0x0463F (17983): - Valores distintos (2): 0x00, 0xAD - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xAD -> 83 veces - -Offset 0x04640 (17984): - Valores distintos (2): 0x00, 0xD8 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xD8 -> 83 veces - -Offset 0x04641 (17985): - Valores distintos (2): 0x00, 0x45 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x45 -> 83 veces - -Offset 0x04642 (17986): - Valores distintos (2): 0x00, 0x9E - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x9E -> 30 veces - -Offset 0x04648 (17992): - Valores distintos (7): 0x00, 0x13, 0x17, 0x1E, 0x21, 0x24, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0x13 -> 39 veces - 0x2A -> 30 veces - 0x17 -> 17 veces - 0x1E -> 16 veces - -Offset 0x04649 (17993): - Valores distintos (3): 0x00, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0xFF -> 39 veces - 0xFD -> 36 veces - -Offset 0x0464A (17994): - Valores distintos (3): 0x00, 0x03, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 159 veces - 0xFE -> 39 veces - 0x03 -> 36 veces - -Offset 0x0464B (17995): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 142 veces - 0x01 -> 92 veces - -Offset 0x0464C (17996): - Valores distintos (3): 0x00, 0x01, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0xFD -> 36 veces - 0x01 -> 14 veces - -Offset 0x0464D (17997): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 159 veces - 0x01 -> 75 veces - -Offset 0x0464E (17998): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 182 veces - 0x03 -> 36 veces - 0x01 -> 16 veces - -Offset 0x0466E (18030): - Valores distintos (6): 0x01, 0x09, 0x11, 0x12, 0x13, 0x14 - Clasificación: small_state - Más frecuentes: - 0x09 -> 71 veces - 0x01 -> 66 veces - 0x13 -> 55 veces - 0x11 -> 21 veces - 0x14 -> 11 veces - -Offset 0x0466F (18031): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x01 -> 151 veces - 0x00 -> 83 veces - -Offset 0x04670 (18032): - Valores distintos (8): 0x00, 0x0B, 0x3C, 0x46, 0x47, 0x55, 0x5A, 0xEB - Clasificación: small_state - Más frecuentes: - 0x00 -> 66 veces - 0x0B -> 46 veces - 0x47 -> 36 veces - 0x46 -> 25 veces - 0xEB -> 21 veces - -Offset 0x04671 (18033): - Valores distintos (7): 0x00, 0x04, 0x1F, 0x29, 0x31, 0x32, 0x33 - Clasificación: small_state - Más frecuentes: - 0x04 -> 71 veces - 0x00 -> 66 veces - 0x31 -> 36 veces - 0x1F -> 21 veces - 0x32 -> 19 veces - -Offset 0x04675 (18037): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 224 veces - 0x20 -> 10 veces - -Offset 0x04676 (18038): - Valores distintos (3): 0x00, 0x3A, 0x3C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x3C -> 78 veces - 0x3A -> 19 veces - -Offset 0x04677 (18039): - Valores distintos (4): 0x00, 0x33, 0x36, 0x37 - Clasificación: small_state - Más frecuentes: - 0x37 -> 78 veces - 0x33 -> 71 veces - 0x00 -> 66 veces - 0x36 -> 19 veces - -Offset 0x04678 (18040): - Valores distintos (2): 0x00, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x26 -> 97 veces - -Offset 0x04679 (18041): - Valores distintos (3): 0x00, 0x08, 0x0B - Clasificación: small_state - Más frecuentes: - 0x0B -> 97 veces - 0x08 -> 71 veces - 0x00 -> 66 veces - -Offset 0x0467A (18042): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 156 veces - 0x02 -> 78 veces - -Offset 0x0467B (18043): - Valores distintos (3): 0x00, 0x01, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 142 veces - 0x01 -> 78 veces - 0x0A -> 14 veces - -Offset 0x0467C (18044): - Valores distintos (7): 0x01, 0x28, 0x54, 0xAC, 0xB9, 0xC9, 0xD1 - Clasificación: small_state - Más frecuentes: - 0x54 -> 71 veces - 0x28 -> 66 veces - 0xC9 -> 50 veces - 0xAC -> 21 veces - 0xD1 -> 11 veces - -Offset 0x0467E (18046): - Valores distintos (5): 0x08, 0x24, 0x3C, 0x43, 0x46 - Clasificación: small_state - Más frecuentes: - 0x24 -> 71 veces - 0x08 -> 66 veces - 0x43 -> 65 veces - 0x3C -> 21 veces - 0x46 -> 11 veces - -Offset 0x04682 (18050): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 224 veces - 0x02 -> 10 veces - -Offset 0x04683 (18051): - Valores distintos (3): 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 122 veces - 0xFF -> 66 veces - 0x02 -> 46 veces - -Offset 0x04684 (18052): - Valores distintos (6): 0x28, 0x54, 0x99, 0xAC, 0xC9, 0xD1 - Clasificación: small_state - Más frecuentes: - 0x54 -> 71 veces - 0x28 -> 66 veces - 0xC9 -> 55 veces - 0xAC -> 21 veces - 0xD1 -> 11 veces - -Offset 0x04686 (18054): - Valores distintos (5): 0x08, 0x24, 0x3C, 0x43, 0x46 - Clasificación: small_state - Más frecuentes: - 0x24 -> 71 veces - 0x08 -> 66 veces - 0x43 -> 65 veces - 0x3C -> 21 veces - 0x46 -> 11 veces - -Offset 0x04688 (18056): - Valores distintos (7): 0x12, 0x1C, 0x5B, 0x7A, 0x81, 0x84, 0x88 - Clasificación: small_state - Más frecuentes: - 0x1C -> 71 veces - 0x12 -> 66 veces - 0x84 -> 55 veces - 0x5B -> 19 veces - 0x88 -> 11 veces - -Offset 0x0468A (18058): - Valores distintos (7): 0x0E, 0x3A, 0x7B, 0x85, 0x8D, 0x92, 0x98 - Clasificación: small_state - Más frecuentes: - 0x3A -> 71 veces - 0x0E -> 66 veces - 0x92 -> 55 veces - 0x7B -> 19 veces - 0x98 -> 11 veces - -Offset 0x0468C (18060): - Valores distintos (3): 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 137 veces - 0x01 -> 78 veces - 0x02 -> 19 veces - -Offset 0x0468E (18062): - Valores distintos (3): 0x04, 0x1C, 0x1F - Clasificación: small_state - Más frecuentes: - 0x1F -> 97 veces - 0x1C -> 71 veces - 0x04 -> 66 veces - -Offset 0x04693 (18067): - Valores distintos (2): 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x02 -> 188 veces - 0x01 -> 46 veces - -Offset 0x04694 (18068): - Valores distintos (2): 0x02, 0x07 - Clasificación: small_state - Más frecuentes: - 0x02 -> 220 veces - 0x07 -> 14 veces - -Offset 0x046A4 (18084): - Valores distintos (6): 0x28, 0x54, 0xAC, 0xBF, 0xC9, 0xD1 - Clasificación: small_state - Más frecuentes: - 0x54 -> 71 veces - 0x28 -> 66 veces - 0xC9 -> 55 veces - 0xAC -> 21 veces - 0xD1 -> 11 veces - -Offset 0x046A6 (18086): - Valores distintos (5): 0x08, 0x24, 0x3C, 0x43, 0x46 - Clasificación: small_state - Más frecuentes: - 0x24 -> 71 veces - 0x08 -> 66 veces - 0x43 -> 65 veces - 0x3C -> 21 veces - 0x46 -> 11 veces - -Offset 0x046A8 (18088): - Valores distintos (6): 0x12, 0x1C, 0x42, 0x49, 0x4C, 0x50 - Clasificación: small_state - Más frecuentes: - 0x1C -> 71 veces - 0x12 -> 66 veces - 0x4C -> 55 veces - 0x42 -> 21 veces - 0x50 -> 11 veces - -Offset 0x046AA (18090): - Valores distintos (6): 0x0E, 0x27, 0x56, 0x5E, 0x63, 0x69 - Clasificación: small_state - Más frecuentes: - 0x27 -> 71 veces - 0x0E -> 66 veces - 0x63 -> 55 veces - 0x56 -> 21 veces - 0x69 -> 11 veces - -Offset 0x046AC (18092): - Valores distintos (2): 0x03, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 168 veces - 0x03 -> 66 veces - -Offset 0x046AE (18094): - Valores distintos (3): 0x04, 0x1C, 0x1F - Clasificación: small_state - Más frecuentes: - 0x1F -> 97 veces - 0x1C -> 71 veces - 0x04 -> 66 veces - -Offset 0x046C4 (18116): - Valores distintos (2): 0x00, 0x47 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x47 -> 11 veces - -Offset 0x046CE (18126): - Valores distintos (2): 0x00, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x30 -> 97 veces - -Offset 0x046CF (18127): - Valores distintos (2): 0x00, 0x33 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x33 -> 97 veces - -Offset 0x046E2 (18146): - Valores distintos (2): 0x00, 0x3A - Clasificación: small_state - Más frecuentes: - 0x3A -> 168 veces - 0x00 -> 66 veces - -Offset 0x046E3 (18147): - Valores distintos (2): 0x00, 0x24 - Clasificación: small_state - Más frecuentes: - 0x24 -> 168 veces - 0x00 -> 66 veces - -Offset 0x046E4 (18148): - Valores distintos (2): 0x00, 0xB9 - Clasificación: small_state - Más frecuentes: - 0xB9 -> 168 veces - 0x00 -> 66 veces - -Offset 0x046EC (18156): - Valores distintos (3): 0x00, 0x01, 0x09 - Clasificación: small_state - Más frecuentes: - 0x09 -> 122 veces - 0x00 -> 66 veces - 0x01 -> 46 veces - -Offset 0x046ED (18157): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 122 veces - 0x00 -> 66 veces - 0xFF -> 46 veces - -Offset 0x046EE (18158): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 188 veces - 0x01 -> 46 veces - -Offset 0x046EF (18159): - Valores distintos (3): 0x00, 0x01, 0xFE - Clasificación: small_state - Más frecuentes: - 0x01 -> 122 veces - 0x00 -> 66 veces - 0xFE -> 46 veces - -Offset 0x046F0 (18160): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 122 veces - 0x00 -> 66 veces - 0x01 -> 46 veces - -Offset 0x046F1 (18161): - Valores distintos (2): 0x00, 0xFD - Clasificación: small_state - Más frecuentes: - 0xFD -> 122 veces - 0x00 -> 112 veces - -Offset 0x046F2 (18162): - Valores distintos (3): 0x00, 0x02, 0xFD - Clasificación: small_state - Más frecuentes: - 0xFD -> 122 veces - 0x00 -> 66 veces - 0x02 -> 46 veces - -Offset 0x0471A (18202): - Valores distintos (2): 0x00, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 146 veces - 0x00 -> 88 veces - -Offset 0x0471D (18205): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x0A -> 146 veces - 0x00 -> 88 veces - -Offset 0x04720 (18208): - Valores distintos (3): 0x07, 0x0F, 0x77 - Clasificación: small_state - Más frecuentes: - 0x77 -> 146 veces - 0x0F -> 80 veces - 0x07 -> 8 veces - -Offset 0x04728 (18216): - Valores distintos (2): 0x0F, 0x77 - Clasificación: small_state - Más frecuentes: - 0x77 -> 146 veces - 0x0F -> 88 veces - -Offset 0x0472C (18220): - Valores distintos (2): 0x0A, 0x75 - Clasificación: small_state - Más frecuentes: - 0x75 -> 146 veces - 0x0A -> 88 veces - -Offset 0x0472E (18222): - Valores distintos (2): 0x08, 0x54 - Clasificación: small_state - Más frecuentes: - 0x54 -> 146 veces - 0x08 -> 88 veces - -Offset 0x04730 (18224): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 146 veces - 0x04 -> 88 veces - -Offset 0x04732 (18226): - Valores distintos (2): 0x08, 0x0C - Clasificación: small_state - Más frecuentes: - 0x0C -> 146 veces - 0x08 -> 88 veces - -Offset 0x04748 (18248): - Valores distintos (2): 0x0F, 0x77 - Clasificación: small_state - Más frecuentes: - 0x77 -> 146 veces - 0x0F -> 88 veces - -Offset 0x0474C (18252): - Valores distintos (2): 0x0A, 0x4A - Clasificación: small_state - Más frecuentes: - 0x4A -> 146 veces - 0x0A -> 88 veces - -Offset 0x0474E (18254): - Valores distintos (2): 0x08, 0x3F - Clasificación: small_state - Más frecuentes: - 0x3F -> 146 veces - 0x08 -> 88 veces - -Offset 0x04750 (18256): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 146 veces - 0x04 -> 88 veces - -Offset 0x04752 (18258): - Valores distintos (2): 0x08, 0x0C - Clasificación: small_state - Más frecuentes: - 0x0C -> 146 veces - 0x08 -> 88 veces - -Offset 0x04786 (18310): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x03 -> 83 veces - -Offset 0x047B8 (18360): - Valores distintos (3): 0x03, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 223 veces - 0x03 -> 8 veces - 0x0F -> 3 veces - -Offset 0x047B9 (18361): - Valores distintos (3): 0x00, 0x06, 0xBE - Clasificación: small_state - Más frecuentes: - 0xBE -> 205 veces - 0x06 -> 18 veces - 0x00 -> 11 veces - -Offset 0x047BA (18362): - Valores distintos (2): 0x00, 0x74 - Clasificación: small_state - Más frecuentes: - 0x74 -> 205 veces - 0x00 -> 29 veces - -Offset 0x047BB (18363): - Valores distintos (3): 0x1E, 0x1F, 0x3F - Clasificación: small_state - Más frecuentes: - 0x3F -> 205 veces - 0x1F -> 21 veces - 0x1E -> 8 veces - -Offset 0x047BF (18367): - Valores distintos (3): 0x00, 0x5E, 0x82 - Clasificación: small_state - Más frecuentes: - 0x5E -> 205 veces - 0x82 -> 18 veces - 0x00 -> 11 veces - -Offset 0x047C0 (18368): - Valores distintos (2): 0x00, 0xFB - Clasificación: small_state - Más frecuentes: - 0xFB -> 205 veces - 0x00 -> 29 veces - -Offset 0x047C1 (18369): - Valores distintos (2): 0x00, 0x91 - Clasificación: small_state - Más frecuentes: - 0x91 -> 205 veces - 0x00 -> 29 veces - -Offset 0x047C2 (18370): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 205 veces - 0x00 -> 29 veces - -Offset 0x047C3 (18371): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 205 veces - 0x00 -> 29 veces - -Offset 0x047C4 (18372): - Valores distintos (2): 0x00, 0xF1 - Clasificación: small_state - Más frecuentes: - 0xF1 -> 205 veces - 0x00 -> 29 veces - -Offset 0x047C5 (18373): - Valores distintos (2): 0x00, 0xC2 - Clasificación: small_state - Más frecuentes: - 0xC2 -> 205 veces - 0x00 -> 29 veces - -Offset 0x047C6 (18374): - Valores distintos (2): 0x00, 0xCF - Clasificación: small_state - Más frecuentes: - 0xCF -> 205 veces - 0x00 -> 29 veces - -Offset 0x047C7 (18375): - Valores distintos (2): 0x00, 0xC5 - Clasificación: small_state - Más frecuentes: - 0xC5 -> 205 veces - 0x00 -> 29 veces - -Offset 0x047C8 (18376): - Valores distintos (3): 0x00, 0x7E, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 190 veces - 0x00 -> 29 veces - 0x7E -> 15 veces - -Offset 0x047C9 (18377): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 190 veces - 0x00 -> 44 veces - -Offset 0x047CA (18378): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 190 veces - 0x00 -> 44 veces - -Offset 0x047CB (18379): - Valores distintos (2): 0x00, 0x7F - Clasificación: small_state - Más frecuentes: - 0x7F -> 190 veces - 0x00 -> 44 veces - -Offset 0x047D0 (18384): - Valores distintos (3): 0x00, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 183 veces - 0x00 -> 44 veces - 0x3F -> 7 veces - -Offset 0x047D1 (18385): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x15 -> 183 veces - 0x00 -> 51 veces - -Offset 0x047D8 (18392): - Valores distintos (2): 0x00, 0x67 - Clasificación: small_state - Más frecuentes: - 0x67 -> 183 veces - 0x00 -> 51 veces - -Offset 0x047D9 (18393): - Valores distintos (3): 0x00, 0x03, 0xDF - Clasificación: small_state - Más frecuentes: - 0xDF -> 168 veces - 0x00 -> 51 veces - 0x03 -> 15 veces - -Offset 0x047DA (18394): - Valores distintos (2): 0x00, 0x9F - Clasificación: small_state - Más frecuentes: - 0x9F -> 168 veces - 0x00 -> 66 veces - -Offset 0x047DB (18395): - Valores distintos (2): 0x00, 0xE7 - Clasificación: small_state - Más frecuentes: - 0xE7 -> 168 veces - 0x00 -> 66 veces - -Offset 0x047DC (18396): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 168 veces - 0x00 -> 66 veces - -Offset 0x047DD (18397): - Valores distintos (3): 0x00, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 146 veces - 0x00 -> 68 veces - 0x1F -> 20 veces - -Offset 0x047DE (18398): - Valores distintos (3): 0x00, 0x30, 0x37 - Clasificación: small_state - Más frecuentes: - 0x37 -> 146 veces - 0x00 -> 66 veces - 0x30 -> 22 veces - -Offset 0x047DF (18399): - Valores distintos (4): 0x00, 0x08, 0x18, 0x78 - Clasificación: small_state - Más frecuentes: - 0x78 -> 146 veces - 0x00 -> 66 veces - 0x18 -> 20 veces - 0x08 -> 2 veces - -Offset 0x047E0 (18400): - Valores distintos (2): 0x00, 0xFB - Clasificación: small_state - Más frecuentes: - 0xFB -> 146 veces - 0x00 -> 88 veces - -Offset 0x047E1 (18401): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 146 veces - 0x00 -> 88 veces - -Offset 0x047E2 (18402): - Valores distintos (2): 0x00, 0x7F - Clasificación: small_state - Más frecuentes: - 0x7F -> 146 veces - 0x00 -> 88 veces - -Offset 0x047E3 (18403): - Valores distintos (2): 0x00, 0xFC - Clasificación: small_state - Más frecuentes: - 0xFC -> 146 veces - 0x00 -> 88 veces - -Offset 0x047E4 (18404): - Valores distintos (2): 0x00, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 146 veces - 0x00 -> 88 veces - -Offset 0x047E5 (18405): - Valores distintos (3): 0x00, 0x07, 0x17 - Clasificación: small_state - Más frecuentes: - 0x17 -> 140 veces - 0x00 -> 89 veces - 0x07 -> 5 veces - -Offset 0x047E7 (18407): - Valores distintos (4): 0x00, 0x38, 0xB8, 0xF8 - Clasificación: small_state - Más frecuentes: - 0xF8 -> 97 veces - 0x00 -> 88 veces - 0xB8 -> 43 veces - 0x38 -> 6 veces - -Offset 0x047E8 (18408): - Valores distintos (2): 0x00, 0xDF - Clasificación: small_state - Más frecuentes: - 0xDF -> 140 veces - 0x00 -> 94 veces - -Offset 0x047E9 (18409): - Valores distintos (3): 0x00, 0x18, 0x1B - Clasificación: small_state - Más frecuentes: - 0x1B -> 137 veces - 0x00 -> 94 veces - 0x18 -> 3 veces - -Offset 0x047F0 (18416): - Valores distintos (3): 0x00, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 127 veces - 0x00 -> 97 veces - 0x1F -> 10 veces - -Offset 0x047F1 (18417): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 127 veces - 0x00 -> 107 veces - -Offset 0x047F2 (18418): - Valores distintos (2): 0x00, 0x7B - Clasificación: small_state - Más frecuentes: - 0x7B -> 127 veces - 0x00 -> 107 veces - -Offset 0x047F3 (18419): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 127 veces - 0x00 -> 107 veces - -Offset 0x047F8 (18424): - Valores distintos (3): 0x00, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 122 veces - 0x00 -> 107 veces - 0x7F -> 5 veces - -Offset 0x047F9 (18425): - Valores distintos (2): 0x00, 0xF9 - Clasificación: small_state - Más frecuentes: - 0xF9 -> 122 veces - 0x00 -> 112 veces - -Offset 0x047FA (18426): - Valores distintos (2): 0x00, 0xEF - Clasificación: small_state - Más frecuentes: - 0xEF -> 122 veces - 0x00 -> 112 veces - -Offset 0x047FB (18427): - Valores distintos (3): 0x00, 0x3F, 0x7F - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0x7F -> 97 veces - 0x3F -> 25 veces - -Offset 0x047FC (18428): - Valores distintos (3): 0x00, 0xC0, 0xDF - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0xDF -> 97 veces - 0xC0 -> 25 veces - -Offset 0x047FD (18429): - Valores distintos (2): 0x00, 0xD0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xD0 -> 97 veces - -Offset 0x047FE (18430): - Valores distintos (2): 0x00, 0xD7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xD7 -> 97 veces - -Offset 0x047FF (18431): - Valores distintos (3): 0x00, 0x60, 0xE7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0xE7 -> 97 veces - 0x60 -> 25 veces - -Offset 0x04800 (18432): - Valores distintos (2): 0x00, 0xF7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xF7 -> 97 veces - -Offset 0x04801 (18433): - Valores distintos (2): 0x00, 0xEF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xEF -> 97 veces - -Offset 0x04802 (18434): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFF -> 83 veces - 0x09 -> 14 veces - -Offset 0x04803 (18435): - Valores distintos (3): 0x00, 0x04, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x07 -> 83 veces - 0x04 -> 14 veces - -Offset 0x04804 (18436): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xFF -> 83 veces - -Offset 0x04805 (18437): - Valores distintos (2): 0x00, 0xDB - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xDB -> 83 veces - -Offset 0x04806 (18438): - Valores distintos (2): 0x00, 0xF0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xF0 -> 97 veces - -Offset 0x04807 (18439): - Valores distintos (2): 0x00, 0x3F - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x3F -> 97 veces - -Offset 0x04808 (18440): - Valores distintos (2): 0x00, 0xF7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xF7 -> 83 veces - -Offset 0x04809 (18441): - Valores distintos (3): 0x00, 0x01, 0xDF - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0xDF -> 83 veces - 0x01 -> 44 veces - -Offset 0x0480A (18442): - Valores distintos (2): 0x00, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x0F -> 83 veces - -Offset 0x04810 (18448): - Valores distintos (3): 0x00, 0x01, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x07 -> 78 veces - 0x01 -> 2 veces - -Offset 0x04812 (18450): - Valores distintos (2): 0x00, 0xF0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0xF0 -> 80 veces - -Offset 0x04813 (18451): - Valores distintos (2): 0x00, 0x43 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x43 -> 80 veces - -Offset 0x04814 (18452): - Valores distintos (2): 0x00, 0xF0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0xF0 -> 80 veces - -Offset 0x04815 (18453): - Valores distintos (3): 0x00, 0x1F, 0xBF - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0xBF -> 78 veces - 0x1F -> 2 veces - -Offset 0x04816 (18454): - Valores distintos (3): 0x00, 0x40, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x41 -> 78 veces - 0x40 -> 2 veces - -Offset 0x04817 (18455): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 156 veces - 0x80 -> 78 veces - -Offset 0x04818 (18456): - Valores distintos (4): 0x00, 0x01, 0x7D, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 156 veces - 0xFD -> 66 veces - 0x7D -> 10 veces - 0x01 -> 2 veces - -Offset 0x04819 (18457): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0xFF -> 66 veces - -Offset 0x0481A (18458): - Valores distintos (3): 0x00, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0xFF -> 50 veces - 0x7F -> 16 veces - -Offset 0x0481B (18459): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0xFF -> 50 veces - -Offset 0x04820 (18464): - Valores distintos (3): 0x00, 0x01, 0xD1 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0xD1 -> 45 veces - 0x01 -> 5 veces - -Offset 0x04821 (18465): - Valores distintos (4): 0x00, 0x1F, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0xFF -> 30 veces - 0x1F -> 9 veces - 0x7F -> 6 veces - -Offset 0x04822 (18466): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0x03 -> 34 veces - 0xFF -> 11 veces - -Offset 0x04823 (18467): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xFF -> 11 veces - -Offset 0x04826 (18470): - Valores distintos (3): 0x00, 0x20, 0x23 - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0x20 -> 34 veces - 0x23 -> 11 veces - -Offset 0x04828 (18472): - Valores distintos (2): 0x00, 0x7F - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x7F -> 11 veces - -Offset 0x0482C (18476): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xFF -> 11 veces - -Offset 0x0482D (18477): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xFF -> 11 veces - -Offset 0x04850 (18512): - Valores distintos (4): 0x08, 0x18, 0x38, 0xF8 - Clasificación: small_state - Más frecuentes: - 0xF8 -> 140 veces - 0x08 -> 88 veces - 0x38 -> 5 veces - 0x18 -> 1 veces - -Offset 0x04851 (18513): - Valores distintos (3): 0x00, 0x20, 0xE0 - Clasificación: small_state - Más frecuentes: - 0xE0 -> 127 veces - 0x20 -> 56 veces - 0x00 -> 51 veces - -Offset 0x04853 (18515): - Valores distintos (2): 0x0A, 0x2F - Clasificación: small_state - Más frecuentes: - 0x2F -> 137 veces - 0x0A -> 97 veces - -Offset 0x04854 (18516): - Valores distintos (2): 0x00, 0x08 - Clasificación: small_state - Más frecuentes: - 0x08 -> 140 veces - 0x00 -> 94 veces - -Offset 0x04855 (18517): - Valores distintos (4): 0x00, 0x80, 0x86, 0xE6 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x80 -> 66 veces - 0xE6 -> 66 veces - 0x86 -> 14 veces - -Offset 0x04856 (18518): - Valores distintos (6): 0x00, 0x42, 0x4A, 0xCA, 0xDE, 0xEE - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0xDE -> 45 veces - 0x42 -> 40 veces - 0xEE -> 21 veces - 0x4A -> 17 veces - -Offset 0x04857 (18519): - Valores distintos (2): 0x00, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0xFD -> 66 veces - -Offset 0x04858 (18520): - Valores distintos (5): 0x00, 0x08, 0x25, 0x29, 0xB9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x29 -> 47 veces - 0xB9 -> 45 veces - 0x08 -> 40 veces - 0x25 -> 5 veces - -Offset 0x04859 (18521): - Valores distintos (3): 0x00, 0x20, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x2A -> 45 veces - 0x20 -> 5 veces - -Offset 0x0485A (18522): - Valores distintos (3): 0x00, 0x01, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x11 -> 50 veces - 0x01 -> 47 veces - -Offset 0x0485B (18523): - Valores distintos (4): 0x00, 0x08, 0x18, 0x1E - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x1E -> 45 veces - 0x08 -> 33 veces - 0x18 -> 5 veces - -Offset 0x0485C (18524): - Valores distintos (3): 0x00, 0x3F, 0xBF - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0xBF -> 30 veces - 0x3F -> 20 veces - -Offset 0x0485D (18525): - Valores distintos (4): 0x00, 0xE9, 0xED, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xE9 -> 52 veces - 0xFD -> 36 veces - 0xED -> 9 veces - -Offset 0x0485E (18526): - Valores distintos (3): 0x00, 0x07, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x07 -> 67 veces - 0x0F -> 30 veces - -Offset 0x0485F (18527): - Valores distintos (4): 0x00, 0x80, 0xC2, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x80 -> 97 veces - 0xC2 -> 19 veces - 0xFE -> 11 veces - -Offset 0x04860 (18528): - Valores distintos (4): 0x00, 0x18, 0x1C, 0xDD - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x18 -> 47 veces - 0x1C -> 39 veces - 0xDD -> 11 veces - -Offset 0x04861 (18529): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x80 -> 36 veces - -Offset 0x04862 (18530): - Valores distintos (5): 0x00, 0x20, 0x38, 0x3B, 0x3F - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x20 -> 31 veces - 0x38 -> 30 veces - 0x3B -> 25 veces - 0x3F -> 11 veces - -Offset 0x04863 (18531): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x0486E (18542): - Valores distintos (3): 0x00, 0xC0, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xE0 -> 66 veces - 0xC0 -> 31 veces - -Offset 0x0486F (18543): - Valores distintos (4): 0x00, 0x07, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x0F -> 44 veces - 0xFF -> 36 veces - 0x07 -> 17 veces - -Offset 0x04878 (18552): - Valores distintos (31): 0x0C, 0x1D, 0x22, 0x2D, 0x35, 0x44, 0x45, 0x48, 0x49, 0x4B, 0x5A, 0x65, 0x72, 0x75, 0x77, 0x88, 0x93, 0xAB, 0xB4, 0xB8, 0xB9, 0xBB, 0xC4, 0xC6, 0xDD, 0xE0, 0xE1, 0xE5, 0xE7, 0xE8, 0xFC - Clasificación: bitfield_like - Más frecuentes: - 0xC4 -> 26 veces - 0x93 -> 25 veces - 0xAB -> 20 veces - 0x2D -> 17 veces - 0xE5 -> 16 veces - -Offset 0x04879 (18553): - Valores distintos (26): 0x00, 0x01, 0x03, 0x05, 0x09, 0x0A, 0x0B, 0x11, 0x13, 0x15, 0x17, 0x1B, 0x1C, 0x24, 0x25, 0x26, 0x27, 0x35, 0x47, 0x53, 0x5F, 0x60, 0x67, 0xB3, 0xE7, 0xEB - Clasificación: bitfield_like - Más frecuentes: - 0x26 -> 30 veces - 0x35 -> 25 veces - 0x01 -> 18 veces - 0xE7 -> 17 veces - 0x24 -> 16 veces - -Offset 0x0487A (18554): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x0487C (18556): - Valores distintos (2): 0x00, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0xE0 -> 5 veces - -Offset 0x0487D (18557): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 229 veces - 0x01 -> 5 veces - -Offset 0x0487E (18558): - Valores distintos (3): 0x00, 0x01, 0x08 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0x08 -> 4 veces - 0x01 -> 1 veces - -Offset 0x0487F (18559): - Valores distintos (4): 0x00, 0x23, 0x28, 0xF0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0xF0 -> 45 veces - 0x23 -> 4 veces - 0x28 -> 1 veces - -Offset 0x04880 (18560): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 166 veces - 0x01 -> 68 veces - -Offset 0x04881 (18561): - Valores distintos (3): 0x07, 0x2F, 0x3F - Clasificación: small_state - Más frecuentes: - 0x07 -> 168 veces - 0x3F -> 50 veces - 0x2F -> 16 veces - -Offset 0x04882 (18562): - Valores distintos (5): 0x00, 0x01, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 112 veces - 0x00 -> 82 veces - 0x05 -> 31 veces - 0x01 -> 7 veces - 0x04 -> 2 veces - -Offset 0x04883 (18563): - Valores distintos (9): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 47 veces - 0x05 -> 41 veces - 0x02 -> 40 veces - 0x01 -> 25 veces - 0x07 -> 25 veces - -Offset 0x04884 (18564): - Valores distintos (9): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 68 veces - 0x05 -> 50 veces - 0x02 -> 34 veces - 0xFF -> 25 veces - 0x06 -> 17 veces - -Offset 0x04885 (18565): - Valores distintos (5): 0x00, 0x01, 0x04, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 125 veces - 0x00 -> 73 veces - 0x04 -> 23 veces - 0x06 -> 12 veces - 0x01 -> 1 veces - -Offset 0x04886 (18566): - Valores distintos (9): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x04 -> 60 veces - 0x02 -> 55 veces - 0x05 -> 48 veces - 0x00 -> 18 veces - 0xFF -> 15 veces - -Offset 0x04887 (18567): - Valores distintos (8): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 74 veces - 0x01 -> 36 veces - 0x04 -> 34 veces - 0xFF -> 25 veces - 0x08 -> 22 veces - -Offset 0x04888 (18568): - Valores distintos (6): 0x04, 0x24, 0xA4, 0xAC, 0xEC, 0xEE - Clasificación: small_state - Más frecuentes: - 0xEE -> 97 veces - 0xEC -> 49 veces - 0xAC -> 37 veces - 0xA4 -> 22 veces - 0x24 -> 21 veces - -Offset 0x04889 (18569): - Valores distintos (6): 0x08, 0x0C, 0x0E, 0x4E, 0xCE, 0xCF - Clasificación: small_state - Más frecuentes: - 0xCF -> 146 veces - 0xCE -> 37 veces - 0x4E -> 22 veces - 0x0E -> 18 veces - 0x08 -> 6 veces - -Offset 0x0488A (18570): - Valores distintos (4): 0x80, 0xAE, 0xBE, 0xBF - Clasificación: small_state - Más frecuentes: - 0xBF -> 122 veces - 0xBE -> 68 veces - 0x80 -> 29 veces - 0xAE -> 15 veces - -Offset 0x0488B (18571): - Valores distintos (2): 0x67, 0xE7 - Clasificación: small_state - Más frecuentes: - 0xE7 -> 190 veces - 0x67 -> 44 veces - -Offset 0x0488C (18572): - Valores distintos (6): 0x00, 0xE0, 0xE6, 0xEE, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE6 -> 114 veces - 0xEE -> 31 veces - 0xFF -> 30 veces - 0x00 -> 29 veces - 0xE0 -> 15 veces - -Offset 0x0488D (18573): - Valores distintos (6): 0x00, 0x80, 0x83, 0x93, 0xB3, 0xF3 - Clasificación: small_state - Más frecuentes: - 0x93 -> 124 veces - 0xB3 -> 36 veces - 0xF3 -> 30 veces - 0x80 -> 18 veces - 0x83 -> 15 veces - -Offset 0x0488E (18574): - Valores distintos (5): 0x04, 0x2D, 0x3F, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2D -> 78 veces - 0xFF -> 76 veces - 0x3F -> 49 veces - 0x04 -> 29 veces - 0xBF -> 2 veces - -Offset 0x0488F (18575): - Valores distintos (8): 0x00, 0x60, 0x61, 0x63, 0xE3, 0xF3, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF7 -> 86 veces - 0x63 -> 37 veces - 0x00 -> 29 veces - 0xF3 -> 25 veces - 0xE3 -> 24 veces - -Offset 0x04890 (18576): - Valores distintos (5): 0x00, 0x02, 0x82, 0x92, 0xF2 - Clasificación: small_state - Más frecuentes: - 0x92 -> 92 veces - 0x00 -> 51 veces - 0xF2 -> 45 veces - 0x02 -> 37 veces - 0x82 -> 9 veces - -Offset 0x04891 (18577): - Valores distintos (3): 0x00, 0x40, 0x78 - Clasificación: small_state - Más frecuentes: - 0x78 -> 166 veces - 0x00 -> 66 veces - 0x40 -> 2 veces - -Offset 0x04892 (18578): - Valores distintos (5): 0x00, 0x02, 0x07, 0xE7, 0xEF - Clasificación: small_state - Más frecuentes: - 0xE7 -> 135 veces - 0x07 -> 44 veces - 0x00 -> 29 veces - 0x02 -> 15 veces - 0xEF -> 11 veces - -Offset 0x04893 (18579): - Valores distintos (5): 0x00, 0x10, 0x56, 0x5E, 0x7E - Clasificación: small_state - Más frecuentes: - 0x7E -> 140 veces - 0x00 -> 51 veces - 0x10 -> 37 veces - 0x5E -> 5 veces - 0x56 -> 1 veces - -Offset 0x04894 (18580): - Valores distintos (4): 0x00, 0x1E, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 97 veces - 0x00 -> 94 veces - 0xFE -> 40 veces - 0x1E -> 3 veces - -Offset 0x04895 (18581): - Valores distintos (5): 0x00, 0x01, 0xC1, 0xED, 0xFD - Clasificación: small_state - Más frecuentes: - 0xED -> 77 veces - 0x00 -> 51 veces - 0xFD -> 50 veces - 0x01 -> 46 veces - 0xC1 -> 10 veces - -Offset 0x04896 (18582): - Valores distintos (6): 0x00, 0x04, 0x14, 0xFC, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 67 veces - 0xFF -> 50 veces - 0x00 -> 45 veces - 0xFD -> 26 veces - 0x14 -> 25 veces - -Offset 0x04897 (18583): - Valores distintos (4): 0x00, 0xA0, 0xA8, 0xA9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0xA9 -> 36 veces - 0xA0 -> 21 veces - 0xA8 -> 9 veces - -Offset 0x04898 (18584): - Valores distintos (6): 0x00, 0x12, 0x32, 0x36, 0xB7, 0xF7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xB7 -> 39 veces - 0x36 -> 28 veces - 0xF7 -> 11 veces - 0x12 -> 3 veces - -Offset 0x04899 (18585): - Valores distintos (6): 0x00, 0x20, 0x30, 0x38, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x7F -> 25 veces - 0x30 -> 16 veces - 0x38 -> 14 veces - 0xFF -> 11 veces - -Offset 0x0489A (18586): - Valores distintos (7): 0x00, 0x40, 0x48, 0x49, 0x5D, 0x5F, 0xDF - Clasificación: small_state - Más frecuentes: - 0x00 -> 156 veces - 0x5F -> 25 veces - 0x49 -> 16 veces - 0x5D -> 14 veces - 0xDF -> 11 veces - -Offset 0x0489B (18587): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xFF -> 11 veces - -Offset 0x0489C (18588): - Valores distintos (7): 0x00, 0x10, 0x30, 0x38, 0x78, 0xF8, 0xFF - Clasificación: small_state - Más frecuentes: - 0x38 -> 95 veces - 0x00 -> 51 veces - 0x10 -> 37 veces - 0xF8 -> 19 veces - 0x78 -> 15 veces - -Offset 0x0489D (18589): - Valores distintos (6): 0x00, 0x08, 0xC8, 0xE8, 0xEC, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 117 veces - 0x00 -> 51 veces - 0xE8 -> 20 veces - 0xEC -> 19 veces - 0xC8 -> 16 veces - -Offset 0x0489E (18590): - Valores distintos (5): 0x00, 0x01, 0x03, 0x0F, 0x2F - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0x03 -> 47 veces - 0x0F -> 39 veces - 0x01 -> 25 veces - 0x2F -> 11 veces - -Offset 0x048A8 (18600): - Valores distintos (3): 0x00, 0x08, 0x48 - Clasificación: small_state - Más frecuentes: - 0x08 -> 110 veces - 0x00 -> 88 veces - 0x48 -> 36 veces - -Offset 0x048A9 (18601): - Valores distintos (3): 0x00, 0x04, 0x84 - Clasificación: small_state - Más frecuentes: - 0x84 -> 127 veces - 0x00 -> 88 veces - 0x04 -> 19 veces - -Offset 0x048AA (18602): - Valores distintos (4): 0x00, 0x10, 0x50, 0x59 - Clasificación: small_state - Más frecuentes: - 0x10 -> 96 veces - 0x00 -> 88 veces - 0x50 -> 39 veces - 0x59 -> 11 veces - -Offset 0x048AB (18603): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x04 -> 127 veces - 0x00 -> 107 veces - -Offset 0x048AC (18604): - Valores distintos (4): 0x00, 0x80, 0x90, 0xD0 - Clasificación: small_state - Más frecuentes: - 0x90 -> 157 veces - 0x00 -> 34 veces - 0x80 -> 32 veces - 0xD0 -> 11 veces - -Offset 0x048AD (18605): - Valores distintos (4): 0x00, 0x04, 0x05, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x05 -> 25 veces - 0x04 -> 14 veces - 0x0F -> 11 veces - -Offset 0x048AF (18607): - Valores distintos (4): 0x00, 0x04, 0x44, 0xC4 - Clasificación: small_state - Más frecuentes: - 0x04 -> 138 veces - 0x00 -> 66 veces - 0x44 -> 19 veces - 0xC4 -> 11 veces - -Offset 0x048B0 (18608): - Valores distintos (2): 0x00, 0x20 - Clasificación: small_state - Más frecuentes: - 0x20 -> 205 veces - 0x00 -> 29 veces - -Offset 0x048B6 (18614): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x80 -> 205 veces - 0x00 -> 29 veces - -Offset 0x048B9 (18617): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x10 -> 11 veces - -Offset 0x048BB (18619): - Valores distintos (4): 0x00, 0x02, 0x66, 0x76 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x02 -> 97 veces - 0x66 -> 19 veces - 0x76 -> 11 veces - -Offset 0x048BC (18620): - Valores distintos (4): 0x00, 0x30, 0x70, 0x78 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x30 -> 63 veces - 0x70 -> 47 veces - 0x78 -> 36 veces - -Offset 0x048BD (18621): - Valores distintos (5): 0x00, 0x04, 0x26, 0x36, 0x3E - Clasificación: small_state - Más frecuentes: - 0x04 -> 122 veces - 0x26 -> 47 veces - 0x00 -> 29 veces - 0x36 -> 25 veces - 0x3E -> 11 veces - -Offset 0x048BE (18622): - Valores distintos (2): 0x00, 0x08 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x08 -> 97 veces - -Offset 0x048BF (18623): - Valores distintos (3): 0x00, 0x02, 0x12 - Clasificación: small_state - Más frecuentes: - 0x02 -> 102 veces - 0x00 -> 66 veces - 0x12 -> 66 veces - -Offset 0x048C0 (18624): - Valores distintos (4): 0x00, 0x08, 0x48, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x58 -> 36 veces - 0x08 -> 16 veces - 0x48 -> 14 veces - -Offset 0x048C1 (18625): - Valores distintos (4): 0x00, 0x80, 0x8A, 0xCA - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x80 -> 61 veces - 0xCA -> 30 veces - 0x8A -> 6 veces - -Offset 0x048C3 (18627): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x048E8 (18664): - Valores distintos (26): 0x00, 0x01, 0x02, 0x06, 0x07, 0x09, 0x0A, 0x0D, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x21, 0x25, 0x26, 0x27, 0x2A, 0x2E, 0x2F, 0x30, 0x34, 0x3B, 0x3C, 0x45, 0x46 - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 25 veces - 0x0D -> 22 veces - 0x02 -> 18 veces - 0x3C -> 17 veces - 0x2A -> 16 veces - -Offset 0x048E9 (18665): - Valores distintos (29): 0x00, 0x02, 0x04, 0x06, 0x08, 0x09, 0x0B, 0x0D, 0x11, 0x13, 0x14, 0x16, 0x18, 0x19, 0x1A, 0x1C, 0x24, 0x25, 0x26, 0x27, 0x28, 0x2A, 0x2B, 0x30, 0x31, 0x33, 0x34, 0x36, 0x38 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 25 veces - 0x08 -> 24 veces - 0x18 -> 20 veces - 0x25 -> 17 veces - 0x24 -> 16 veces - -Offset 0x048EA (18666): - Valores distintos (24): 0x00, 0x01, 0x06, 0x08, 0x09, 0x0B, 0x0C, 0x0D, 0x0E, 0x11, 0x12, 0x15, 0x19, 0x1B, 0x1E, 0x21, 0x23, 0x27, 0x2A, 0x31, 0x32, 0x33, 0x36, 0x39 - Clasificación: bitfield_like - Más frecuentes: - 0x11 -> 34 veces - 0x2A -> 31 veces - 0x01 -> 25 veces - 0x1E -> 20 veces - 0x21 -> 18 veces - -Offset 0x048EB (18667): - Valores distintos (20): 0x01, 0x03, 0x05, 0x07, 0x08, 0x09, 0x0C, 0x0E, 0x0F, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18, 0x1A, 0x1B, 0x1C, 0x1D - Clasificación: bitfield_like - Más frecuentes: - 0x16 -> 40 veces - 0x0C -> 28 veces - 0x12 -> 25 veces - 0x0F -> 20 veces - 0x1C -> 16 veces - -Offset 0x048ED (18669): - Valores distintos (5): 0x00, 0x20, 0x36, 0x7E, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 137 veces - 0x7E -> 68 veces - 0x36 -> 18 veces - 0x00 -> 8 veces - 0x20 -> 3 veces - -Offset 0x048EE (18670): - Valores distintos (5): 0x00, 0x38, 0x3C, 0xF8, 0xFB - Clasificación: small_state - Más frecuentes: - 0xFB -> 137 veces - 0xF8 -> 53 veces - 0x00 -> 29 veces - 0x38 -> 10 veces - 0x3C -> 5 veces - -Offset 0x048EF (18671): - Valores distintos (4): 0x00, 0x80, 0x8D, 0x8F - Clasificación: small_state - Más frecuentes: - 0x8F -> 97 veces - 0x8D -> 93 veces - 0x00 -> 29 veces - 0x80 -> 15 veces - -Offset 0x048F0 (18672): - Valores distintos (4): 0x00, 0x01, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 183 veces - 0x00 -> 29 veces - 0x01 -> 16 veces - 0x0F -> 6 veces - -Offset 0x048F1 (18673): - Valores distintos (4): 0x00, 0x07, 0x77, 0xF7 - Clasificación: small_state - Más frecuentes: - 0x77 -> 116 veces - 0x00 -> 51 veces - 0x07 -> 37 veces - 0xF7 -> 30 veces - -Offset 0x048F2 (18674): - Valores distintos (4): 0x00, 0x14, 0xFC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 97 veces - 0x00 -> 88 veces - 0xFC -> 43 veces - 0x14 -> 6 veces - -Offset 0x048F3 (18675): - Valores distintos (4): 0x00, 0x40, 0x47, 0xF7 - Clasificación: small_state - Más frecuentes: - 0xF7 -> 137 veces - 0x00 -> 51 veces - 0x40 -> 43 veces - 0x47 -> 3 veces - -Offset 0x048F4 (18676): - Valores distintos (4): 0x00, 0x08, 0x0F, 0x8F - Clasificación: small_state - Más frecuentes: - 0x8F -> 80 veces - 0x0F -> 57 veces - 0x08 -> 53 veces - 0x00 -> 44 veces - -Offset 0x048F5 (18677): - Valores distintos (5): 0x00, 0x03, 0x5F, 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0xFF -> 83 veces - 0xDF -> 39 veces - 0x03 -> 10 veces - 0x5F -> 5 veces - -Offset 0x048F6 (18678): - Valores distintos (4): 0x00, 0x04, 0x07, 0x7F - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x7F -> 97 veces - 0x07 -> 25 veces - 0x04 -> 5 veces - -Offset 0x048F7 (18679): - Valores distintos (3): 0x00, 0x60, 0x68 - Clasificación: small_state - Más frecuentes: - 0x68 -> 97 veces - 0x00 -> 88 veces - 0x60 -> 49 veces - -Offset 0x048F8 (18680): - Valores distintos (7): 0x00, 0x01, 0x03, 0x23, 0xE3, 0xEB, 0xFB - Clasificación: small_state - Más frecuentes: - 0x01 -> 56 veces - 0xEB -> 55 veces - 0x00 -> 51 veces - 0x03 -> 44 veces - 0xE3 -> 14 veces - -Offset 0x048F9 (18681): - Valores distintos (5): 0x00, 0x38, 0x39, 0x3D, 0xFD - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xFD -> 66 veces - 0x3D -> 10 veces - 0x39 -> 4 veces - 0x38 -> 3 veces - -Offset 0x048FA (18682): - Valores distintos (3): 0x00, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0xFF -> 50 veces - 0x1F -> 16 veces - -Offset 0x048FB (18683): - Valores distintos (3): 0x00, 0x1F, 0x9F - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x9F -> 45 veces - 0x1F -> 5 veces - -Offset 0x048FC (18684): - Valores distintos (4): 0x00, 0x01, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x3F -> 19 veces - 0xFF -> 11 veces - 0x01 -> 6 veces - -Offset 0x048FD (18685): - Valores distintos (2): 0x00, 0xBB - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xBB -> 11 veces - -Offset 0x048FE (18686): - Valores distintos (3): 0x00, 0x08, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x09 -> 97 veces - 0x08 -> 40 veces - -Offset 0x048FF (18687): - Valores distintos (5): 0x00, 0x20, 0x2C, 0x3E, 0xFE - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x20 -> 59 veces - 0xFE -> 45 veces - 0x2C -> 28 veces - 0x3E -> 5 veces - -Offset 0x04900 (18688): - Valores distintos (4): 0x00, 0xA0, 0xA6, 0xA7 - Clasificación: small_state - Más frecuentes: - 0xA0 -> 156 veces - 0xA7 -> 30 veces - 0x00 -> 29 veces - 0xA6 -> 19 veces - -Offset 0x04901 (18689): - Valores distintos (4): 0x00, 0x10, 0x30, 0x34 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x34 -> 66 veces - 0x10 -> 57 veces - 0x30 -> 14 veces - -Offset 0x0490C (18700): - Valores distintos (2): 0x00, 0x1B - Clasificación: small_state - Más frecuentes: - 0x1B -> 146 veces - 0x00 -> 88 veces - -Offset 0x0490D (18701): - Valores distintos (3): 0x00, 0x26, 0x27 - Clasificación: small_state - Más frecuentes: - 0x27 -> 146 veces - 0x26 -> 59 veces - 0x00 -> 29 veces - -Offset 0x04910 (18704): - Valores distintos (2): 0x00, 0x3B - Clasificación: small_state - Más frecuentes: - 0x3B -> 146 veces - 0x00 -> 88 veces - -Offset 0x04911 (18705): - Valores distintos (2): 0x00, 0x28 - Clasificación: small_state - Más frecuentes: - 0x28 -> 127 veces - 0x00 -> 107 veces - -Offset 0x04913 (18707): - Valores distintos (2): 0x00, 0x42 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x42 -> 36 veces - -Offset 0x04916 (18710): - Valores distintos (2): 0x00, 0x1F - Clasificación: small_state - Más frecuentes: - 0x1F -> 146 veces - 0x00 -> 88 veces - -Offset 0x04917 (18711): - Valores distintos (2): 0x00, 0x12 - Clasificación: small_state - Más frecuentes: - 0x12 -> 146 veces - 0x00 -> 88 veces - -Offset 0x04918 (18712): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x10 -> 146 veces - 0x00 -> 88 veces - -Offset 0x04919 (18713): - Valores distintos (2): 0x00, 0x18 - Clasificación: small_state - Más frecuentes: - 0x18 -> 140 veces - 0x00 -> 94 veces - -Offset 0x0491A (18714): - Valores distintos (3): 0x00, 0x23, 0x38 - Clasificación: small_state - Más frecuentes: - 0x23 -> 110 veces - 0x00 -> 88 veces - 0x38 -> 36 veces - -Offset 0x0491B (18715): - Valores distintos (3): 0x00, 0x34, 0x37 - Clasificación: small_state - Más frecuentes: - 0x37 -> 140 veces - 0x00 -> 88 veces - 0x34 -> 6 veces - -Offset 0x0491C (18716): - Valores distintos (3): 0x00, 0x26, 0x44 - Clasificación: small_state - Más frecuentes: - 0x26 -> 110 veces - 0x00 -> 88 veces - 0x44 -> 36 veces - -Offset 0x0491D (18717): - Valores distintos (2): 0x00, 0x54 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x54 -> 36 veces - -Offset 0x0491E (18718): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x4B -> 36 veces - -Offset 0x04921 (18721): - Valores distintos (2): 0x00, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x41 -> 83 veces - -Offset 0x0492C (18732): - Valores distintos (4): 0x60, 0x70, 0x7C, 0x7E - Clasificación: small_state - Más frecuentes: - 0x7C -> 175 veces - 0x7E -> 30 veces - 0x70 -> 18 veces - 0x60 -> 11 veces - -Offset 0x0492D (18733): - Valores distintos (3): 0x00, 0x01, 0x85 - Clasificación: small_state - Más frecuentes: - 0x85 -> 205 veces - 0x01 -> 23 veces - 0x00 -> 6 veces - -Offset 0x0492E (18734): - Valores distintos (2): 0x00, 0x0F - Clasificación: small_state - Más frecuentes: - 0x0F -> 205 veces - 0x00 -> 29 veces - -Offset 0x0492F (18735): - Valores distintos (3): 0x00, 0xC0, 0xE0 - Clasificación: small_state - Más frecuentes: - 0xE0 -> 127 veces - 0x00 -> 88 veces - 0xC0 -> 19 veces - -Offset 0x04930 (18736): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 146 veces - 0x00 -> 88 veces - -Offset 0x04931 (18737): - Valores distintos (3): 0x00, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 127 veces - 0x00 -> 88 veces - 0x3F -> 19 veces - -Offset 0x04932 (18738): - Valores distintos (3): 0x00, 0xC0, 0xCC - Clasificación: small_state - Más frecuentes: - 0xCC -> 168 veces - 0x00 -> 51 veces - 0xC0 -> 15 veces - -Offset 0x04933 (18739): - Valores distintos (4): 0x00, 0x04, 0x07, 0x4F - Clasificación: small_state - Más frecuentes: - 0x4F -> 146 veces - 0x00 -> 44 veces - 0x07 -> 37 veces - 0x04 -> 7 veces - -Offset 0x04934 (18740): - Valores distintos (6): 0x00, 0x20, 0xE0, 0xE8, 0xEE, 0xFE - Clasificación: small_state - Más frecuentes: - 0xFE -> 83 veces - 0xEE -> 57 veces - 0x00 -> 44 veces - 0x20 -> 22 veces - 0xE0 -> 22 veces - -Offset 0x04935 (18741): - Valores distintos (5): 0x00, 0x02, 0x03, 0x1B, 0x3B - Clasificación: small_state - Más frecuentes: - 0x3B -> 97 veces - 0x00 -> 66 veces - 0x1B -> 25 veces - 0x03 -> 24 veces - 0x02 -> 22 veces - -Offset 0x04936 (18742): - Valores distintos (6): 0x00, 0x04, 0x14, 0x1C, 0x1E, 0xDE - Clasificación: small_state - Más frecuentes: - 0xDE -> 83 veces - 0x00 -> 66 veces - 0x1C -> 40 veces - 0x04 -> 22 veces - 0x1E -> 14 veces - -Offset 0x04937 (18743): - Valores distintos (5): 0x00, 0x01, 0x03, 0x97, 0xD7 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0xD7 -> 36 veces - 0x01 -> 30 veces - 0x97 -> 9 veces - 0x03 -> 5 veces - -Offset 0x04938 (18744): - Valores distintos (6): 0x00, 0x80, 0xC0, 0xC1, 0xCD, 0xFD - Clasificación: small_state - Más frecuentes: - 0x80 -> 93 veces - 0xC0 -> 52 veces - 0x00 -> 44 veces - 0xCD -> 25 veces - 0xFD -> 11 veces - -Offset 0x04939 (18745): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 168 veces - 0x01 -> 66 veces - -Offset 0x0494C (18764): - Valores distintos (9): 0x80, 0x81, 0x83, 0x85, 0x87, 0x8A, 0x8B, 0x8D, 0x90 - Clasificación: bitfield_like - Más frecuentes: - 0x8D -> 55 veces - 0x81 -> 44 veces - 0x87 -> 33 veces - 0x85 -> 29 veces - 0x8A -> 22 veces - -Offset 0x0494D (18765): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 219 veces - 0x80 -> 15 veces - -Offset 0x0494E (18766): - Valores distintos (6): 0x00, 0x1C, 0x1D, 0x1E, 0x21, 0x29 - Clasificación: small_state - Más frecuentes: - 0x1C -> 59 veces - 0x1E -> 53 veces - 0x21 -> 44 veces - 0x1D -> 36 veces - 0x00 -> 29 veces - -Offset 0x0494F (18767): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 205 veces - 0x00 -> 29 veces - -Offset 0x04950 (18768): - Valores distintos (6): 0x00, 0x2E, 0x2F, 0x30, 0x31, 0x32 - Clasificación: small_state - Más frecuentes: - 0x2F -> 63 veces - 0x2E -> 59 veces - 0x31 -> 36 veces - 0x32 -> 30 veces - 0x00 -> 29 veces - -Offset 0x04951 (18769): - Valores distintos (18): 0x07, 0x1B, 0x30, 0x32, 0x34, 0x42, 0x4A, 0x4D, 0x54, 0x61, 0x6B, 0x6F, 0x70, 0x71, 0x83, 0x8B, 0x8C, 0x95 - Clasificación: bitfield_like - Más frecuentes: - 0x4D -> 28 veces - 0x8C -> 28 veces - 0x71 -> 27 veces - 0x61 -> 25 veces - 0x4A -> 20 veces - -Offset 0x04954 (18772): - Valores distintos (29): 0x0E, 0x17, 0x1B, 0x1C, 0x1F, 0x2F, 0x3E, 0x48, 0x4F, 0x52, 0x5D, 0x62, 0x63, 0x76, 0x84, 0x87, 0xA0, 0xA7, 0xAF, 0xB0, 0xBE, 0xC0, 0xC8, 0xCB, 0xD5, 0xEF, 0xF2, 0xF6, 0xFB - Clasificación: bitfield_like - Más frecuentes: - 0xA7 -> 25 veces - 0x63 -> 20 veces - 0x1B -> 18 veces - 0x3E -> 18 veces - 0x4F -> 17 veces - -Offset 0x04955 (18773): - Valores distintos (8): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 51 veces - 0x01 -> 43 veces - 0x02 -> 43 veces - 0x03 -> 31 veces - 0x04 -> 30 veces - -Offset 0x04958 (18776): - Valores distintos (32): 0x03, 0x10, 0x21, 0x24, 0x2B, 0x3C, 0x3F, 0x56, 0x5A, 0x61, 0x62, 0x66, 0x6A, 0x6D, 0x72, 0x76, 0x7A, 0x7F, 0x81, 0x89, 0x99, 0x9E, 0x9F, 0xC1, 0xCB, 0xCE, 0xD2, 0xDB, 0xEB, 0xF1, 0xF3, 0xFD - Clasificación: bitfield_like - Más frecuentes: - 0x6D -> 25 veces - 0x7F -> 20 veces - 0x76 -> 18 veces - 0xCB -> 17 veces - 0x03 -> 16 veces - -Offset 0x04959 (18777): - Valores distintos (32): 0x00, 0x01, 0x03, 0x04, 0x0F, 0x11, 0x15, 0x16, 0x1D, 0x26, 0x2D, 0x36, 0x37, 0x38, 0x51, 0x58, 0x6B, 0x70, 0x81, 0x87, 0x88, 0x8F, 0x93, 0x96, 0x9B, 0x9C, 0xB3, 0xC7, 0xCD, 0xD3, 0xE6, 0xF6 - Clasificación: bitfield_like - Más frecuentes: - 0xCD -> 25 veces - 0x38 -> 20 veces - 0x04 -> 18 veces - 0x1D -> 17 veces - 0xE6 -> 16 veces - -Offset 0x0495A (18778): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 47 veces - 0x05 -> 17 veces - 0x02 -> 14 veces - 0x06 -> 11 veces - -Offset 0x0495C (18780): - Valores distintos (21): 0x02, 0x03, 0x04, 0x0C, 0x0F, 0x13, 0x19, 0x2E, 0x30, 0x31, 0x34, 0x36, 0x39, 0x3C, 0x3D, 0x3E, 0x3F, 0x43, 0x46, 0x47, 0x49 - Clasificación: bitfield_like - Más frecuentes: - 0x36 -> 25 veces - 0x19 -> 22 veces - 0x47 -> 19 veces - 0x04 -> 18 veces - 0x3E -> 16 veces - -Offset 0x04960 (18784): - Valores distintos (28): 0x02, 0x03, 0x06, 0x1E, 0x22, 0x26, 0x2E, 0x31, 0x3A, 0x52, 0x53, 0x5C, 0x64, 0x72, 0x80, 0x83, 0xA7, 0xAE, 0xB3, 0xB5, 0xB7, 0xCA, 0xDC, 0xE4, 0xE9, 0xEA, 0xF2, 0xFC - Clasificación: bitfield_like - Más frecuentes: - 0x83 -> 25 veces - 0x53 -> 21 veces - 0xF2 -> 19 veces - 0x06 -> 18 veces - 0xCA -> 16 veces - -Offset 0x04964 (18788): - Valores distintos (10): 0x00, 0x01, 0x07, 0x08, 0x0A, 0x0B, 0x0D, 0x0E, 0x15, 0x16 - Clasificación: bitfield_like - Más frecuentes: - 0x01 -> 59 veces - 0x0A -> 30 veces - 0x0E -> 30 veces - 0x16 -> 30 veces - 0x00 -> 29 veces - -Offset 0x04969 (18793): - Valores distintos (4): 0x00, 0x50, 0x62, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 194 veces - 0x80 -> 35 veces - 0x50 -> 4 veces - 0x62 -> 1 veces - -Offset 0x0496A (18794): - Valores distintos (19): 0x00, 0x05, 0x12, 0x24, 0x25, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2E, 0x30, 0x31, 0x32, 0x34, 0x38, 0x39, 0x3B, 0x4D - Clasificación: bitfield_like - Más frecuentes: - 0x29 -> 40 veces - 0x05 -> 35 veces - 0x32 -> 22 veces - 0x12 -> 18 veces - 0x30 -> 17 veces - -Offset 0x0496B (18795): - Valores distintos (3): 0x00, 0x12, 0x13 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0x13 -> 4 veces - 0x12 -> 1 veces - -Offset 0x0496C (18796): - Valores distintos (2): 0x00, 0x80 - Clasificación: small_state - Más frecuentes: - 0x00 -> 233 veces - 0x80 -> 1 veces - -Offset 0x0496D (18797): - Valores distintos (3): 0x00, 0x13, 0xC0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0xC0 -> 4 veces - 0x13 -> 1 veces - -Offset 0x0496E (18798): - Valores distintos (19): 0x00, 0x06, 0x13, 0x19, 0x1A, 0x1D, 0x1E, 0x26, 0x28, 0x2A, 0x2D, 0x31, 0x32, 0x38, 0x3B, 0x3C, 0x3D, 0x3F, 0xDD - Clasificación: bitfield_like - Más frecuentes: - 0x32 -> 40 veces - 0x06 -> 35 veces - 0x38 -> 22 veces - 0x13 -> 18 veces - 0x3D -> 14 veces - -Offset 0x0496F (18799): - Valores distintos (3): 0x00, 0x10, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 229 veces - 0x10 -> 4 veces - 0x14 -> 1 veces - -Offset 0x04970 (18800): - Valores distintos (11): 0x00, 0x10, 0x21, 0x2D, 0x41, 0x57, 0x58, 0x62, 0x97, 0x98, 0xBD - Clasificación: bitfield_like - Más frecuentes: - 0x41 -> 52 veces - 0x2D -> 37 veces - 0x62 -> 35 veces - 0x21 -> 23 veces - 0x10 -> 21 veces - -Offset 0x04972 (18802): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 174 veces - 0x01 -> 60 veces - -Offset 0x04973 (18803): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 112 veces - 0x03 -> 47 veces - 0x05 -> 38 veces - 0x02 -> 25 veces - 0x06 -> 11 veces - -Offset 0x04974 (18804): - Valores distintos (2): 0x04, 0x5B - Clasificación: small_state - Más frecuentes: - 0x04 -> 184 veces - 0x5B -> 50 veces - -Offset 0x04978 (18808): - Valores distintos (2): 0x00, 0x0D - Clasificación: small_state - Más frecuentes: - 0x0D -> 226 veces - 0x00 -> 8 veces - -Offset 0x04979 (18809): - Valores distintos (4): 0x00, 0x0A, 0x22, 0x27 - Clasificación: small_state - Más frecuentes: - 0x0A -> 190 veces - 0x22 -> 18 veces - 0x27 -> 15 veces - 0x00 -> 11 veces - -Offset 0x0497A (18810): - Valores distintos (4): 0x00, 0x06, 0x0A, 0x27 - Clasificación: small_state - Más frecuentes: - 0x06 -> 190 veces - 0x27 -> 18 veces - 0x0A -> 15 veces - 0x00 -> 11 veces - -Offset 0x0497B (18811): - Valores distintos (4): 0x00, 0x06, 0x0A, 0x39 - Clasificación: small_state - Más frecuentes: - 0x39 -> 190 veces - 0x0A -> 18 veces - 0x06 -> 15 veces - 0x00 -> 11 veces - -Offset 0x0497C (18812): - Valores distintos (4): 0x00, 0x1A, 0x27, 0x39 - Clasificación: small_state - Más frecuentes: - 0x27 -> 97 veces - 0x1A -> 93 veces - 0x00 -> 29 veces - 0x39 -> 15 veces - -Offset 0x0497D (18813): - Valores distintos (5): 0x00, 0x05, 0x08, 0x1A, 0x27 - Clasificación: small_state - Más frecuentes: - 0x08 -> 97 veces - 0x00 -> 51 veces - 0x27 -> 49 veces - 0x05 -> 22 veces - 0x1A -> 15 veces - -Offset 0x0497E (18814): - Valores distintos (5): 0x00, 0x05, 0x08, 0x0B, 0x0F - Clasificación: small_state - Más frecuentes: - 0x0F -> 97 veces - 0x08 -> 64 veces - 0x00 -> 51 veces - 0x05 -> 15 veces - 0x0B -> 7 veces - -Offset 0x0497F (18815): - Valores distintos (5): 0x00, 0x0B, 0x0F, 0x22, 0x43 - Clasificación: small_state - Más frecuentes: - 0x43 -> 97 veces - 0x0F -> 86 veces - 0x00 -> 29 veces - 0x0B -> 15 veces - 0x22 -> 7 veces - -Offset 0x04980 (18816): - Valores distintos (6): 0x00, 0x0B, 0x18, 0x22, 0x43, 0x44 - Clasificación: small_state - Más frecuentes: - 0x44 -> 97 veces - 0x43 -> 49 veces - 0x0B -> 37 veces - 0x00 -> 29 veces - 0x22 -> 15 veces - -Offset 0x04981 (18817): - Valores distintos (6): 0x00, 0x15, 0x18, 0x22, 0x3C, 0x44 - Clasificación: small_state - Más frecuentes: - 0x3C -> 97 veces - 0x44 -> 49 veces - 0x22 -> 37 veces - 0x00 -> 29 veces - 0x18 -> 15 veces - -Offset 0x04982 (18818): - Valores distintos (7): 0x00, 0x15, 0x16, 0x18, 0x38, 0x3C, 0x47 - Clasificación: small_state - Más frecuentes: - 0x38 -> 97 veces - 0x00 -> 39 veces - 0x18 -> 37 veces - 0x3C -> 30 veces - 0x15 -> 15 veces - -Offset 0x04983 (18819): - Valores distintos (7): 0x00, 0x02, 0x15, 0x16, 0x38, 0x3C, 0x58 - Clasificación: small_state - Más frecuentes: - 0x02 -> 97 veces - 0x15 -> 37 veces - 0x38 -> 30 veces - 0x00 -> 29 veces - 0x3C -> 19 veces - -Offset 0x04984 (18820): - Valores distintos (9): 0x00, 0x12, 0x16, 0x1F, 0x28, 0x38, 0x42, 0x4A, 0x58 - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 61 veces - 0x16 -> 37 veces - 0x1F -> 30 veces - 0x00 -> 29 veces - 0x4A -> 25 veces - -Offset 0x04985 (18821): - Valores distintos (7): 0x00, 0x02, 0x14, 0x1F, 0x42, 0x46, 0x58 - Clasificación: small_state - Más frecuentes: - 0x42 -> 86 veces - 0x00 -> 44 veces - 0x58 -> 37 veces - 0x02 -> 30 veces - 0x1F -> 19 veces - -Offset 0x04986 (18822): - Valores distintos (7): 0x00, 0x02, 0x08, 0x12, 0x28, 0x45, 0x46 - Clasificación: small_state - Más frecuentes: - 0x46 -> 86 veces - 0x00 -> 44 veces - 0x12 -> 37 veces - 0x28 -> 30 veces - 0x02 -> 19 veces - -Offset 0x04987 (18823): - Valores distintos (6): 0x00, 0x05, 0x14, 0x19, 0x28, 0x45 - Clasificación: small_state - Más frecuentes: - 0x45 -> 86 veces - 0x00 -> 51 veces - 0x14 -> 37 veces - 0x19 -> 30 veces - 0x28 -> 19 veces - -Offset 0x04988 (18824): - Valores distintos (6): 0x00, 0x05, 0x07, 0x19, 0x21, 0x42 - Clasificación: small_state - Más frecuentes: - 0x05 -> 86 veces - 0x00 -> 51 veces - 0x21 -> 37 veces - 0x42 -> 30 veces - 0x19 -> 19 veces - -Offset 0x04989 (18825): - Valores distintos (5): 0x00, 0x07, 0x42, 0x46, 0x56 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x07 -> 86 veces - 0x46 -> 30 veces - 0x42 -> 19 veces - 0x56 -> 11 veces - -Offset 0x0498A (18826): - Valores distintos (5): 0x00, 0x09, 0x1D, 0x46, 0x56 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x56 -> 86 veces - 0x1D -> 30 veces - 0x46 -> 19 veces - 0x09 -> 11 veces - -Offset 0x0498B (18827): - Valores distintos (6): 0x00, 0x0B, 0x1D, 0x23, 0x3D, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x3D -> 86 veces - 0x57 -> 30 veces - 0x1D -> 13 veces - 0x23 -> 11 veces - -Offset 0x0498C (18828): - Valores distintos (6): 0x00, 0x0B, 0x1A, 0x1C, 0x22, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x0B -> 86 veces - 0x1C -> 30 veces - 0x57 -> 13 veces - 0x1A -> 11 veces - -Offset 0x0498D (18829): - Valores distintos (5): 0x00, 0x18, 0x1C, 0x1F, 0x45 - Clasificación: small_state - Más frecuentes: - 0x18 -> 92 veces - 0x00 -> 88 veces - 0x45 -> 30 veces - 0x1C -> 13 veces - 0x1F -> 11 veces - -Offset 0x0498E (18830): - Valores distintos (5): 0x00, 0x05, 0x0B, 0x15, 0x19 - Clasificación: small_state - Más frecuentes: - 0x15 -> 92 veces - 0x00 -> 88 veces - 0x05 -> 30 veces - 0x0B -> 13 veces - 0x19 -> 11 veces - -Offset 0x0498F (18831): - Valores distintos (5): 0x00, 0x07, 0x16, 0x1D, 0x22 - Clasificación: small_state - Más frecuentes: - 0x16 -> 92 veces - 0x00 -> 88 veces - 0x07 -> 30 veces - 0x22 -> 13 veces - 0x1D -> 11 veces - -Offset 0x04990 (18832): - Valores distintos (6): 0x00, 0x12, 0x18, 0x56, 0x57, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x12 -> 86 veces - 0x56 -> 30 veces - 0x18 -> 13 veces - 0x57 -> 11 veces - -Offset 0x04991 (18833): - Valores distintos (6): 0x00, 0x12, 0x14, 0x15, 0x1C, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x14 -> 86 veces - 0x3D -> 30 veces - 0x15 -> 13 veces - 0x1C -> 11 veces - -Offset 0x04992 (18834): - Valores distintos (6): 0x00, 0x0B, 0x14, 0x16, 0x1E, 0x21 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x21 -> 86 veces - 0x0B -> 30 veces - 0x16 -> 13 veces - 0x1E -> 11 veces - -Offset 0x04993 (18835): - Valores distintos (6): 0x00, 0x21, 0x22, 0x28, 0x48, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x48 -> 86 veces - 0x22 -> 30 veces - 0x58 -> 13 veces - 0x28 -> 11 veces - -Offset 0x04994 (18836): - Valores distintos (6): 0x00, 0x0E, 0x12, 0x18, 0x24, 0x48 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x0E -> 86 veces - 0x18 -> 30 veces - 0x12 -> 13 veces - 0x24 -> 11 veces - -Offset 0x04995 (18837): - Valores distintos (6): 0x00, 0x0E, 0x14, 0x15, 0x17, 0x1B - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x17 -> 86 veces - 0x15 -> 30 veces - 0x14 -> 13 veces - 0x1B -> 11 veces - -Offset 0x04996 (18838): - Valores distintos (6): 0x00, 0x04, 0x16, 0x20, 0x21, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x20 -> 86 veces - 0x16 -> 30 veces - 0x21 -> 13 veces - 0x04 -> 11 veces - -Offset 0x04997 (18839): - Valores distintos (7): 0x00, 0x09, 0x1A, 0x1D, 0x48, 0x58, 0x5A - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x09 -> 72 veces - 0x58 -> 30 veces - 0x1A -> 14 veces - 0x48 -> 13 veces - -Offset 0x04998 (18840): - Valores distintos (6): 0x00, 0x0E, 0x12, 0x1F, 0x23, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x23 -> 72 veces - 0x12 -> 30 veces - 0x1F -> 14 veces - 0x0E -> 13 veces - -Offset 0x04999 (18841): - Valores distintos (6): 0x00, 0x14, 0x19, 0x1A, 0x26, 0x4A - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x1A -> 72 veces - 0x14 -> 30 veces - 0x19 -> 14 veces - 0x26 -> 13 veces - -Offset 0x0499A (18842): - Valores distintos (6): 0x00, 0x1D, 0x1F, 0x21, 0x3D, 0x45 - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x1F -> 72 veces - 0x21 -> 30 veces - 0x1D -> 14 veces - 0x45 -> 13 veces - -Offset 0x0499B (18843): - Valores distintos (6): 0x00, 0x05, 0x0B, 0x19, 0x48, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x19 -> 72 veces - 0x48 -> 30 veces - 0x57 -> 14 veces - 0x05 -> 13 veces - -Offset 0x0499C (18844): - Valores distintos (6): 0x00, 0x07, 0x0E, 0x18, 0x1C, 0x1D - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x1D -> 72 veces - 0x0E -> 30 veces - 0x1C -> 14 veces - 0x18 -> 11 veces - -Offset 0x0499D (18845): - Valores distintos (6): 0x00, 0x15, 0x17, 0x22, 0x26, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x57 -> 72 veces - 0x26 -> 30 veces - 0x22 -> 14 veces - 0x15 -> 11 veces - -Offset 0x0499E (18846): - Valores distintos (5): 0x00, 0x16, 0x17, 0x1C, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x1C -> 72 veces - 0x17 -> 30 veces - 0x58 -> 14 veces - 0x16 -> 11 veces - -Offset 0x0499F (18847): - Valores distintos (5): 0x00, 0x12, 0x20, 0x22, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x22 -> 72 veces - 0x20 -> 30 veces - 0x26 -> 14 veces - 0x12 -> 11 veces - -Offset 0x049A0 (18848): - Valores distintos (4): 0x00, 0x14, 0x32, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x58 -> 72 veces - 0x32 -> 44 veces - 0x14 -> 11 veces - -Offset 0x049A1 (18849): - Valores distintos (4): 0x00, 0x1E, 0x21, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x26 -> 72 veces - 0x1E -> 14 veces - 0x21 -> 11 veces - -Offset 0x049A2 (18850): - Valores distintos (4): 0x00, 0x32, 0x48, 0x59 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x32 -> 72 veces - 0x59 -> 14 veces - 0x48 -> 11 veces - -Offset 0x049A3 (18851): - Valores distintos (4): 0x00, 0x09, 0x0E, 0x1E - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x1E -> 72 veces - 0x09 -> 14 veces - 0x0E -> 11 veces - -Offset 0x049A4 (18852): - Valores distintos (4): 0x00, 0x17, 0x28, 0x59 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x59 -> 53 veces - 0x28 -> 19 veces - 0x17 -> 11 veces - -Offset 0x049A5 (18853): - Valores distintos (3): 0x00, 0x20, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x4D -> 72 veces - 0x20 -> 11 veces - -Offset 0x049A6 (18854): - Valores distintos (3): 0x00, 0x22, 0x24 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x24 -> 72 veces - 0x22 -> 11 veces - -Offset 0x049A7 (18855): - Valores distintos (3): 0x00, 0x1B, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x1B -> 55 veces - 0x58 -> 11 veces - -Offset 0x049A8 (18856): - Valores distintos (3): 0x00, 0x04, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x04 -> 39 veces - 0x26 -> 11 veces - -Offset 0x049A9 (18857): - Valores distintos (3): 0x00, 0x32, 0x5A - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0x5A -> 34 veces - 0x32 -> 11 veces - -Offset 0x049AA (18858): - Valores distintos (3): 0x00, 0x2A, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x2A -> 19 veces - 0x4D -> 11 veces - -Offset 0x049AB (18859): - Valores distintos (2): 0x00, 0x37 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x37 -> 11 veces - -Offset 0x049F4 (18932): - Valores distintos (9): 0x00, 0x1C, 0x2A, 0x45, 0x46, 0x47, 0x49, 0x4E, 0x52 - Clasificación: bitfield_like - Más frecuentes: - 0x47 -> 62 veces - 0x52 -> 47 veces - 0x46 -> 30 veces - 0x2A -> 25 veces - 0x00 -> 24 veces - -Offset 0x049F5 (18933): - Valores distintos (7): 0x00, 0x02, 0x46, 0x47, 0x48, 0x49, 0x4F - Clasificación: small_state - Más frecuentes: - 0x49 -> 72 veces - 0x48 -> 62 veces - 0x00 -> 30 veces - 0x47 -> 30 veces - 0x02 -> 15 veces - -Offset 0x049F6 (18934): - Valores distintos (9): 0x00, 0x04, 0x07, 0x09, 0x14, 0x1D, 0x46, 0x47, 0x48 - Clasificación: bitfield_like - Más frecuentes: - 0x46 -> 72 veces - 0x00 -> 51 veces - 0x48 -> 30 veces - 0x04 -> 22 veces - 0x07 -> 16 veces - -Offset 0x049F7 (18935): - Valores distintos (10): 0x00, 0x06, 0x09, 0x20, 0x3A, 0x45, 0x47, 0x48, 0x49, 0x4C - Clasificación: bitfield_like - Más frecuentes: - 0x47 -> 72 veces - 0x00 -> 53 veces - 0x49 -> 25 veces - 0x20 -> 20 veces - 0x45 -> 15 veces - -Offset 0x049F8 (18936): - Valores distintos (6): 0x00, 0x06, 0x07, 0x12, 0x20, 0x48 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x48 -> 72 veces - 0x07 -> 44 veces - 0x06 -> 13 veces - 0x12 -> 11 veces - -Offset 0x049F9 (18937): - Valores distintos (7): 0x00, 0x07, 0x20, 0x21, 0x33, 0x39, 0x3A - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x07 -> 72 veces - 0x3A -> 30 veces - 0x21 -> 14 veces - 0x20 -> 13 veces - -Offset 0x049FA (18938): - Valores distintos (6): 0x00, 0x06, 0x21, 0x29, 0x39, 0x40 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x21 -> 72 veces - 0x06 -> 44 veces - 0x39 -> 13 veces - 0x40 -> 11 veces - -Offset 0x049FB (18939): - Valores distintos (6): 0x00, 0x04, 0x06, 0x11, 0x20, 0x29 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x06 -> 72 veces - 0x20 -> 44 veces - 0x29 -> 13 veces - 0x11 -> 11 veces - -Offset 0x049FC (18940): - Valores distintos (6): 0x00, 0x04, 0x1F, 0x20, 0x39, 0x4A - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x20 -> 72 veces - 0x39 -> 44 veces - 0x04 -> 13 veces - 0x4A -> 11 veces - -Offset 0x049FD (18941): - Valores distintos (6): 0x00, 0x1F, 0x29, 0x38, 0x39, 0x49 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x39 -> 72 veces - 0x29 -> 44 veces - 0x1F -> 13 veces - 0x49 -> 11 veces - -Offset 0x049FE (18942): - Valores distintos (6): 0x00, 0x03, 0x04, 0x29, 0x38, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x29 -> 72 veces - 0x04 -> 44 veces - 0x38 -> 13 veces - 0x4D -> 11 veces - -Offset 0x049FF (18943): - Valores distintos (6): 0x00, 0x02, 0x03, 0x04, 0x10, 0x1F - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x04 -> 72 veces - 0x1F -> 44 veces - 0x03 -> 13 veces - 0x10 -> 11 veces - -Offset 0x04A00 (18944): - Valores distintos (6): 0x00, 0x02, 0x1C, 0x1F, 0x26, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x1F -> 72 veces - 0x38 -> 44 veces - 0x02 -> 13 veces - 0x26 -> 11 veces - -Offset 0x04A01 (18945): - Valores distintos (5): 0x00, 0x03, 0x0E, 0x1C, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x38 -> 72 veces - 0x03 -> 44 veces - 0x1C -> 13 veces - 0x0E -> 11 veces - -Offset 0x04A02 (18946): - Valores distintos (5): 0x00, 0x02, 0x03, 0x42, 0x46 - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x03 -> 72 veces - 0x02 -> 44 veces - 0x46 -> 13 veces - 0x42 -> 11 veces - -Offset 0x04A03 (18947): - Valores distintos (4): 0x00, 0x09, 0x0C, 0x1C - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x09 -> 82 veces - 0x1C -> 44 veces - 0x0C -> 11 veces - -Offset 0x04A04 (18948): - Valores distintos (4): 0x00, 0x1C, 0x2A, 0x46 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x1C -> 72 veces - 0x2A -> 14 veces - 0x46 -> 11 veces - -Offset 0x04A05 (18949): - Valores distintos (3): 0x00, 0x02, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x02 -> 72 veces - 0x3D -> 11 veces - -Offset 0x04A06 (18950): - Valores distintos (3): 0x00, 0x0A, 0x47 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x0A -> 69 veces - 0x47 -> 11 veces - -Offset 0x04A07 (18951): - Valores distintos (4): 0x00, 0x48, 0x4A, 0x4C - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x4A -> 67 veces - 0x48 -> 11 veces - 0x4C -> 2 veces - -Offset 0x04A08 (18952): - Valores distintos (3): 0x00, 0x24, 0x3A - Clasificación: small_state - Más frecuentes: - 0x00 -> 156 veces - 0x3A -> 67 veces - 0x24 -> 11 veces - -Offset 0x04A09 (18953): - Valores distintos (3): 0x00, 0x0A, 0x24 - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x24 -> 55 veces - 0x0A -> 11 veces - -Offset 0x04A0A (18954): - Valores distintos (3): 0x00, 0x08, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x0C -> 55 veces - 0x08 -> 11 veces - -Offset 0x04A0B (18955): - Valores distintos (3): 0x00, 0x09, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x11 -> 55 veces - 0x09 -> 11 veces - -Offset 0x04A0C (18956): - Valores distintos (3): 0x00, 0x07, 0x0E - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x0E -> 39 veces - 0x07 -> 11 veces - -Offset 0x04A0D (18957): - Valores distintos (3): 0x00, 0x21, 0x42 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x42 -> 39 veces - 0x21 -> 11 veces - -Offset 0x04A0E (18958): - Valores distintos (4): 0x00, 0x33, 0x3A, 0x52 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x33 -> 33 veces - 0x3A -> 11 veces - 0x52 -> 6 veces - -Offset 0x04A0F (18959): - Valores distintos (3): 0x00, 0x2A, 0x4C - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x4C -> 39 veces - 0x2A -> 11 veces - -Offset 0x04A10 (18960): - Valores distintos (3): 0x00, 0x06, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x3D -> 39 veces - 0x06 -> 11 veces - -Offset 0x04A11 (18961): - Valores distintos (3): 0x00, 0x20, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x4D -> 39 veces - 0x20 -> 11 veces - -Offset 0x04A12 (18962): - Valores distintos (3): 0x00, 0x14, 0x39 - Clasificación: small_state - Más frecuentes: - 0x00 -> 185 veces - 0x14 -> 38 veces - 0x39 -> 11 veces - -Offset 0x04A13 (18963): - Valores distintos (3): 0x00, 0x29, 0x4F - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0x4F -> 34 veces - 0x29 -> 11 veces - -Offset 0x04A14 (18964): - Valores distintos (3): 0x00, 0x04, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x26 -> 25 veces - 0x04 -> 11 veces - -Offset 0x04A15 (18965): - Valores distintos (3): 0x00, 0x08, 0x1F - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x08 -> 25 veces - 0x1F -> 11 veces - -Offset 0x04A16 (18966): - Valores distintos (3): 0x00, 0x38, 0x40 - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x40 -> 19 veces - 0x38 -> 11 veces - -Offset 0x04A17 (18967): - Valores distintos (3): 0x00, 0x03, 0x12 - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x12 -> 19 veces - 0x03 -> 11 veces - -Offset 0x04A18 (18968): - Valores distintos (3): 0x00, 0x02, 0x4E - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x4E -> 19 veces - 0x02 -> 11 veces - -Offset 0x04A19 (18969): - Valores distintos (2): 0x00, 0x1C - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x1C -> 11 veces - -Offset 0x04A1A (18970): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x4B -> 11 veces - -Offset 0x04A1B (18971): - Valores distintos (2): 0x00, 0x35 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x35 -> 11 veces - -Offset 0x04A1C (18972): - Valores distintos (2): 0x00, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x16 -> 11 veces - -Offset 0x04A1D (18973): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x15 -> 11 veces - -Offset 0x04A74 (19060): - Valores distintos (4): 0x00, 0x21, 0x32, 0x33 - Clasificación: small_state - Más frecuentes: - 0x32 -> 160 veces - 0x00 -> 33 veces - 0x33 -> 22 veces - 0x21 -> 19 veces - -Offset 0x04A75 (19061): - Valores distintos (6): 0x00, 0x05, 0x0C, 0x21, 0x32, 0x33 - Clasificación: small_state - Más frecuentes: - 0x33 -> 83 veces - 0x21 -> 45 veces - 0x05 -> 44 veces - 0x00 -> 35 veces - 0x0C -> 14 veces - -Offset 0x04A76 (19062): - Valores distintos (9): 0x00, 0x06, 0x08, 0x23, 0x29, 0x2B, 0x33, 0x36, 0x37 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 75 veces - 0x29 -> 55 veces - 0x23 -> 30 veces - 0x06 -> 19 veces - 0x08 -> 15 veces - -Offset 0x04A77 (19063): - Valores distintos (5): 0x00, 0x05, 0x06, 0x21, 0x38 - Clasificación: small_state - Más frecuentes: - 0x21 -> 86 veces - 0x06 -> 67 veces - 0x00 -> 51 veces - 0x05 -> 19 veces - 0x38 -> 11 veces - -Offset 0x04A78 (19064): - Valores distintos (5): 0x00, 0x03, 0x05, 0x23, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x23 -> 86 veces - 0x05 -> 30 veces - 0x03 -> 19 veces - 0x3E -> 11 veces - -Offset 0x04A79 (19065): - Valores distintos (5): 0x00, 0x03, 0x08, 0x26, 0x3A - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0x26 -> 72 veces - 0x03 -> 30 veces - 0x08 -> 13 veces - 0x3A -> 11 veces - -Offset 0x04A7A (19066): - Valores distintos (6): 0x00, 0x08, 0x0B, 0x26, 0x36, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x36 -> 72 veces - 0x08 -> 30 veces - 0x26 -> 14 veces - 0x3D -> 11 veces - -Offset 0x04A7B (19067): - Valores distintos (6): 0x00, 0x06, 0x0B, 0x0C, 0x23, 0x29 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x0C -> 72 veces - 0x0B -> 30 veces - 0x06 -> 14 veces - 0x29 -> 11 veces - -Offset 0x04A7C (19068): - Valores distintos (5): 0x00, 0x05, 0x0E, 0x11, 0x21 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x11 -> 72 veces - 0x0E -> 40 veces - 0x05 -> 14 veces - 0x21 -> 11 veces - -Offset 0x04A7D (19069): - Valores distintos (5): 0x00, 0x03, 0x06, 0x0C, 0x23 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x06 -> 72 veces - 0x0C -> 30 veces - 0x03 -> 14 veces - 0x23 -> 11 veces - -Offset 0x04A7E (19070): - Valores distintos (5): 0x00, 0x05, 0x08, 0x0A, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x05 -> 72 veces - 0x0A -> 25 veces - 0x26 -> 16 veces - 0x08 -> 14 veces - -Offset 0x04A7F (19071): - Valores distintos (5): 0x00, 0x03, 0x0E, 0x10, 0x27 - Clasificación: small_state - Más frecuentes: - 0x00 -> 132 veces - 0x03 -> 72 veces - 0x0E -> 14 veces - 0x27 -> 11 veces - 0x10 -> 5 veces - -Offset 0x04A80 (19072): - Valores distintos (3): 0x00, 0x08, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x08 -> 72 veces - 0x28 -> 11 veces - -Offset 0x04A81 (19073): - Valores distintos (4): 0x00, 0x0A, 0x0E, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x0E -> 72 veces - 0x0A -> 14 veces - 0x2C -> 11 veces - -Offset 0x04A82 (19074): - Valores distintos (3): 0x00, 0x0A, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x0A -> 72 veces - 0x0C -> 11 veces - -Offset 0x04A83 (19075): - Valores distintos (3): 0x00, 0x10, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x10 -> 72 veces - 0x11 -> 11 veces - -Offset 0x04A84 (19076): - Valores distintos (3): 0x00, 0x06, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x0B -> 72 veces - 0x06 -> 11 veces - -Offset 0x04A85 (19077): - Valores distintos (4): 0x00, 0x05, 0x27, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x27 -> 44 veces - 0x38 -> 25 veces - 0x05 -> 11 veces - -Offset 0x04A86 (19078): - Valores distintos (3): 0x00, 0x03, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x3E -> 69 veces - 0x03 -> 11 veces - -Offset 0x04A87 (19079): - Valores distintos (4): 0x00, 0x08, 0x17, 0x3A - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x3A -> 30 veces - 0x17 -> 25 veces - 0x08 -> 11 veces - -Offset 0x04A88 (19080): - Valores distintos (3): 0x00, 0x0E, 0x12 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x12 -> 39 veces - 0x0E -> 11 veces - -Offset 0x04A89 (19081): - Valores distintos (3): 0x00, 0x0A, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x16 -> 39 veces - 0x0A -> 11 veces - -Offset 0x04A8A (19082): - Valores distintos (4): 0x00, 0x10, 0x14, 0x1A - Clasificación: small_state - Más frecuentes: - 0x00 -> 185 veces - 0x14 -> 34 veces - 0x10 -> 11 veces - 0x1A -> 4 veces - -Offset 0x04A8B (19083): - Valores distintos (5): 0x00, 0x0B, 0x27, 0x3B, 0x3C - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x27 -> 25 veces - 0x0B -> 11 veces - 0x3C -> 9 veces - 0x3B -> 5 veces - -Offset 0x04A8C (19084): - Valores distintos (3): 0x00, 0x17, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x28 -> 25 veces - 0x17 -> 11 veces - -Offset 0x04A8D (19085): - Valores distintos (3): 0x00, 0x12, 0x3A - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x3A -> 19 veces - 0x12 -> 11 veces - -Offset 0x04A8E (19086): - Valores distintos (3): 0x00, 0x16, 0x3D - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x3D -> 19 veces - 0x16 -> 11 veces - -Offset 0x04A8F (19087): - Valores distintos (3): 0x00, 0x14, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x2C -> 19 veces - 0x14 -> 11 veces - -Offset 0x04A90 (19088): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x15 -> 30 veces - -Offset 0x04A91 (19089): - Valores distintos (2): 0x00, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x2A -> 11 veces - -Offset 0x04A92 (19090): - Valores distintos (2): 0x00, 0x3B - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x3B -> 11 veces - -Offset 0x04A93 (19091): - Valores distintos (2): 0x00, 0x2B - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x2B -> 11 veces - -Offset 0x04A94 (19092): - Valores distintos (2): 0x00, 0x1E - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x1E -> 11 veces - -Offset 0x04AF4 (19188): - Valores distintos (4): 0x00, 0x18, 0x1C, 0x21 - Clasificación: small_state - Más frecuentes: - 0x18 -> 146 veces - 0x1C -> 51 veces - 0x21 -> 22 veces - 0x00 -> 15 veces - -Offset 0x04AF5 (19189): - Valores distintos (5): 0x00, 0x09, 0x0A, 0x1F, 0x25 - Clasificación: small_state - Más frecuentes: - 0x09 -> 97 veces - 0x0A -> 49 veces - 0x1F -> 40 veces - 0x00 -> 26 veces - 0x25 -> 22 veces - -Offset 0x04AF6 (19190): - Valores distintos (7): 0x00, 0x05, 0x09, 0x11, 0x1C, 0x28, 0x29 - Clasificación: small_state - Más frecuentes: - 0x11 -> 50 veces - 0x05 -> 47 veces - 0x1C -> 37 veces - 0x00 -> 35 veces - 0x09 -> 30 veces - -Offset 0x04AF7 (19191): - Valores distintos (7): 0x00, 0x04, 0x09, 0x0E, 0x13, 0x1D, 0x1F - Clasificación: small_state - Más frecuentes: - 0x13 -> 50 veces - 0x04 -> 47 veces - 0x1F -> 37 veces - 0x00 -> 35 veces - 0x0E -> 30 veces - -Offset 0x04AF8 (19192): - Valores distintos (6): 0x00, 0x05, 0x0E, 0x12, 0x24, 0x28 - Clasificación: small_state - Más frecuentes: - 0x12 -> 83 veces - 0x00 -> 57 veces - 0x28 -> 37 veces - 0x05 -> 30 veces - 0x24 -> 17 veces - -Offset 0x04AF9 (19193): - Valores distintos (6): 0x00, 0x04, 0x0E, 0x12, 0x1D, 0x29 - Clasificación: small_state - Más frecuentes: - 0x0E -> 72 veces - 0x00 -> 70 veces - 0x1D -> 37 veces - 0x29 -> 30 veces - 0x12 -> 14 veces - -Offset 0x04AFA (19194): - Valores distintos (6): 0x00, 0x0A, 0x0E, 0x21, 0x24, 0x29 - Clasificación: small_state - Más frecuentes: - 0x29 -> 72 veces - 0x00 -> 51 veces - 0x21 -> 49 veces - 0x24 -> 37 veces - 0x0E -> 14 veces - -Offset 0x04AFB (19195): - Valores distintos (6): 0x00, 0x10, 0x21, 0x25, 0x29, 0x2F - Clasificación: small_state - Más frecuentes: - 0x21 -> 72 veces - 0x00 -> 51 veces - 0x25 -> 49 veces - 0x2F -> 37 veces - 0x29 -> 14 veces - -Offset 0x04AFC (19196): - Valores distintos (6): 0x00, 0x08, 0x12, 0x1C, 0x21, 0x25 - Clasificación: small_state - Más frecuentes: - 0x25 -> 72 veces - 0x00 -> 66 veces - 0x1C -> 49 veces - 0x12 -> 22 veces - 0x21 -> 14 veces - -Offset 0x04AFD (19197): - Valores distintos (6): 0x00, 0x16, 0x1C, 0x1F, 0x25, 0x2C - Clasificación: small_state - Más frecuentes: - 0x1C -> 72 veces - 0x00 -> 66 veces - 0x1F -> 49 veces - 0x2C -> 22 veces - 0x25 -> 14 veces - -Offset 0x04AFE (19198): - Valores distintos (5): 0x00, 0x06, 0x1C, 0x1F, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x1F -> 72 veces - 0x28 -> 49 veces - 0x1C -> 14 veces - 0x06 -> 11 veces - -Offset 0x04AFF (19199): - Valores distintos (5): 0x00, 0x02, 0x1D, 0x1F, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x28 -> 72 veces - 0x1D -> 49 veces - 0x1F -> 14 veces - 0x02 -> 11 veces - -Offset 0x04B00 (19200): - Valores distintos (4): 0x00, 0x1D, 0x24, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 99 veces - 0x1D -> 72 veces - 0x24 -> 49 veces - 0x28 -> 14 veces - -Offset 0x04B01 (19201): - Valores distintos (5): 0x00, 0x1D, 0x24, 0x29, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x24 -> 72 veces - 0x2C -> 49 veces - 0x1D -> 14 veces - 0x29 -> 11 veces - -Offset 0x04B02 (19202): - Valores distintos (5): 0x00, 0x20, 0x21, 0x24, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x2C -> 72 veces - 0x20 -> 49 veces - 0x24 -> 14 veces - 0x21 -> 11 veces - -Offset 0x04B03 (19203): - Valores distintos (6): 0x00, 0x20, 0x22, 0x25, 0x2C, 0x2E - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x20 -> 72 veces - 0x22 -> 30 veces - 0x2E -> 19 veces - 0x2C -> 14 veces - -Offset 0x04B04 (19204): - Valores distintos (5): 0x00, 0x1C, 0x20, 0x22, 0x2E - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x22 -> 72 veces - 0x2E -> 30 veces - 0x20 -> 14 veces - 0x1C -> 11 veces - -Offset 0x04B05 (19205): - Valores distintos (5): 0x00, 0x1F, 0x22, 0x2E, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x2E -> 72 veces - 0x30 -> 30 veces - 0x22 -> 14 veces - 0x1F -> 11 veces - -Offset 0x04B06 (19206): - Valores distintos (4): 0x00, 0x28, 0x2E, 0x2F - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x2F -> 72 veces - 0x2E -> 14 veces - 0x28 -> 11 veces - -Offset 0x04B07 (19207): - Valores distintos (4): 0x00, 0x1D, 0x1E, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x1E -> 72 veces - 0x30 -> 14 veces - 0x1D -> 11 veces - -Offset 0x04B08 (19208): - Valores distintos (3): 0x00, 0x24, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x26 -> 72 veces - 0x24 -> 11 veces - -Offset 0x04B09 (19209): - Valores distintos (4): 0x00, 0x0A, 0x0C, 0x2C - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x0A -> 39 veces - 0x0C -> 33 veces - 0x2C -> 11 veces - -Offset 0x04B0A (19210): - Valores distintos (3): 0x00, 0x10, 0x20 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x10 -> 72 veces - 0x20 -> 11 veces - -Offset 0x04B0B (19211): - Valores distintos (4): 0x00, 0x02, 0x22, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 163 veces - 0x30 -> 55 veces - 0x22 -> 11 veces - 0x02 -> 5 veces - -Offset 0x04B0C (19212): - Valores distintos (4): 0x00, 0x01, 0x1E, 0x2B - Clasificación: small_state - Más frecuentes: - 0x00 -> 163 veces - 0x2B -> 55 veces - 0x1E -> 11 veces - 0x01 -> 5 veces - -Offset 0x04B0D (19213): - Valores distintos (4): 0x00, 0x26, 0x31, 0x32 - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0x32 -> 25 veces - 0x26 -> 11 veces - 0x31 -> 9 veces - -Offset 0x04B0E (19214): - Valores distintos (4): 0x00, 0x08, 0x14, 0x2B - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0x08 -> 25 veces - 0x2B -> 11 veces - 0x14 -> 9 veces - -Offset 0x04B0F (19215): - Valores distintos (3): 0x00, 0x16, 0x23 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x16 -> 25 veces - 0x23 -> 11 veces - -Offset 0x04B10 (19216): - Valores distintos (3): 0x00, 0x23, 0x2E - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x23 -> 25 veces - 0x2E -> 11 veces - -Offset 0x04B11 (19217): - Valores distintos (3): 0x00, 0x06, 0x2F - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x06 -> 25 veces - 0x2F -> 11 veces - -Offset 0x04B12 (19218): - Valores distintos (4): 0x00, 0x0C, 0x14, 0x30 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x0C -> 19 veces - 0x30 -> 11 veces - 0x14 -> 6 veces - -Offset 0x04B13 (19219): - Valores distintos (2): 0x00, 0x32 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x32 -> 11 veces - -Offset 0x04B14 (19220): - Valores distintos (2): 0x00, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x0F -> 11 veces - -Offset 0x04B15 (19221): - Valores distintos (2): 0x00, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x15 -> 11 veces - -Offset 0x04B16 (19222): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x05 -> 11 veces - -Offset 0x04B17 (19223): - Valores distintos (2): 0x00, 0x19 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x19 -> 11 veces - -Offset 0x04B74 (19316): - Valores distintos (13): 0x01, 0x02, 0x03, 0x05, 0x07, 0x08, 0x09, 0x0B, 0x0E, 0x12, 0x18, 0x1A, 0x1B - Clasificación: bitfield_like - Más frecuentes: - 0x03 -> 45 veces - 0x1B -> 33 veces - 0x09 -> 32 veces - 0x12 -> 30 veces - 0x02 -> 23 veces - -Offset 0x04B75 (19317): - Valores distintos (5): 0x01, 0x02, 0x03, 0x04, 0x0A - Clasificación: small_state - Más frecuentes: - 0x01 -> 94 veces - 0x02 -> 90 veces - 0x03 -> 20 veces - 0x04 -> 19 veces - 0x0A -> 11 veces - -Offset 0x04B76 (19318): - Valores distintos (11): 0x01, 0x02, 0x0B, 0x0F, 0x13, 0x1E, 0x20, 0x21, 0x22, 0x27, 0x28 - Clasificación: bitfield_like - Más frecuentes: - 0x28 -> 66 veces - 0x21 -> 43 veces - 0x13 -> 22 veces - 0x1E -> 22 veces - 0x02 -> 21 veces - -Offset 0x04B77 (19319): - Valores distintos (18): 0x01, 0x02, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0B, 0x0D, 0x10, 0x12, 0x14, 0x17, 0x18, 0x19, 0x1A, 0x1F, 0x20 - Clasificación: bitfield_like - Más frecuentes: - 0x17 -> 41 veces - 0x1A -> 29 veces - 0x09 -> 25 veces - 0x19 -> 21 veces - 0x0B -> 20 veces - -Offset 0x04B78 (19320): - Valores distintos (11): 0x00, 0x01, 0x03, 0x04, 0x06, 0x09, 0x0C, 0x13, 0x14, 0x15, 0x16 - Clasificación: bitfield_like - Más frecuentes: - 0x0C -> 49 veces - 0x16 -> 47 veces - 0x06 -> 22 veces - 0x09 -> 22 veces - 0x01 -> 21 veces - -Offset 0x04B79 (19321): - Valores distintos (10): 0x00, 0x01, 0x04, 0x05, 0x06, 0x09, 0x0A, 0x0B, 0x0C, 0x0D - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 34 veces - 0x01 -> 33 veces - 0x0B -> 31 veces - 0x06 -> 31 veces - 0x05 -> 30 veces - -Offset 0x04B7A (19322): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 197 veces - 0x04 -> 15 veces - 0x00 -> 11 veces - 0x02 -> 11 veces - -Offset 0x04B7B (19323): - Valores distintos (5): 0x00, 0x01, 0x03, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x06 -> 127 veces - 0x03 -> 44 veces - 0x01 -> 33 veces - 0x05 -> 19 veces - 0x00 -> 11 veces - -Offset 0x04B7C (19324): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x07, 0x0D, 0x0E - Clasificación: small_state - Más frecuentes: - 0x03 -> 55 veces - 0x0E -> 50 veces - 0x02 -> 46 veces - 0x0D -> 33 veces - 0x00 -> 29 veces - -Offset 0x04B7D (19325): - Valores distintos (8): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 51 veces - 0x01 -> 37 veces - 0x02 -> 31 veces - 0x03 -> 30 veces - 0x05 -> 30 veces - -Offset 0x04B7E (19326): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 79 veces - 0x02 -> 52 veces - 0x00 -> 51 veces - 0x03 -> 34 veces - 0x04 -> 18 veces - -Offset 0x04B7F (19327): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x04, 0x0D - Clasificación: small_state - Más frecuentes: - 0x0D -> 97 veces - 0x01 -> 53 veces - 0x02 -> 45 veces - 0x00 -> 29 veces - 0x04 -> 6 veces - -Offset 0x04B80 (19328): - Valores distintos (6): 0x00, 0x01, 0x04, 0x06, 0x0B, 0x0D - Clasificación: small_state - Más frecuentes: - 0x04 -> 112 veces - 0x0D -> 49 veces - 0x00 -> 29 veces - 0x06 -> 22 veces - 0x01 -> 15 veces - -Offset 0x04B81 (19329): - Valores distintos (4): 0x00, 0x01, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x01 -> 141 veces - 0x04 -> 58 veces - 0x00 -> 29 veces - 0x06 -> 6 veces - -Offset 0x04B82 (19330): - Valores distintos (5): 0x00, 0x01, 0x02, 0x0E, 0x1B - Clasificación: small_state - Más frecuentes: - 0x02 -> 100 veces - 0x01 -> 58 veces - 0x00 -> 39 veces - 0x1B -> 22 veces - 0x0E -> 15 veces - -Offset 0x04B83 (19331): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x04 -> 97 veces - 0x01 -> 72 veces - 0x02 -> 36 veces - 0x00 -> 29 veces - -Offset 0x04B84 (19332): - Valores distintos (4): 0x00, 0x01, 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x01 -> 150 veces - 0x02 -> 44 veces - 0x00 -> 29 veces - 0x05 -> 11 veces - -Offset 0x04B85 (19333): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x05 -> 66 veces - 0x01 -> 57 veces - 0x00 -> 44 veces - 0x02 -> 37 veces - 0x04 -> 30 veces - -Offset 0x04B86 (19334): - Valores distintos (4): 0x00, 0x01, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x01 -> 146 veces - 0x00 -> 44 veces - 0x05 -> 25 veces - 0x04 -> 19 veces - -Offset 0x04B87 (19335): - Valores distintos (4): 0x00, 0x01, 0x02, 0x06 - Clasificación: small_state - Más frecuentes: - 0x01 -> 127 veces - 0x00 -> 51 veces - 0x02 -> 45 veces - 0x06 -> 11 veces - -Offset 0x04B88 (19336): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 - Clasificación: small_state - Más frecuentes: - 0x01 -> 76 veces - 0x00 -> 51 veces - 0x06 -> 38 veces - 0x05 -> 34 veces - 0x04 -> 21 veces - -Offset 0x04B89 (19337): - Valores distintos (6): 0x00, 0x01, 0x05, 0x06, 0x08, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x01 -> 49 veces - 0x09 -> 38 veces - 0x06 -> 26 veces - 0x05 -> 21 veces - -Offset 0x04B8A (19338): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x08 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x08 -> 72 veces - 0x01 -> 49 veces - 0x03 -> 14 veces - 0x02 -> 11 veces - -Offset 0x04B8B (19339): - Valores distintos (4): 0x00, 0x01, 0x06, 0x54 - Clasificación: small_state - Más frecuentes: - 0x01 -> 129 veces - 0x00 -> 88 veces - 0x54 -> 11 veces - 0x06 -> 6 veces - -Offset 0x04B8C (19340): - Valores distintos (5): 0x00, 0x01, 0x02, 0x05, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x0A -> 86 veces - 0x02 -> 30 veces - 0x01 -> 19 veces - 0x05 -> 11 veces - -Offset 0x04B8D (19341): - Valores distintos (4): 0x00, 0x01, 0x1C, 0x1D - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x1C -> 73 veces - 0x01 -> 54 veces - 0x1D -> 19 veces - -Offset 0x04B8E (19342): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x03 -> 72 veces - 0x04 -> 30 veces - 0x02 -> 14 veces - 0x0A -> 13 veces - -Offset 0x04B8F (19343): - Valores distintos (4): 0x00, 0x01, 0x03, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x03 -> 86 veces - 0x01 -> 49 veces - 0x05 -> 11 veces - -Offset 0x04B90 (19344): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x1C - Clasificación: small_state - Más frecuentes: - 0x02 -> 92 veces - 0x00 -> 88 veces - 0x03 -> 30 veces - 0x1C -> 13 veces - 0x01 -> 11 veces - -Offset 0x04B91 (19345): - Valores distintos (4): 0x00, 0x01, 0x02, 0x08 - Clasificación: small_state - Más frecuentes: - 0x01 -> 129 veces - 0x00 -> 88 veces - 0x08 -> 11 veces - 0x02 -> 6 veces - -Offset 0x04B92 (19346): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0A - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 88 veces - 0x0A -> 30 veces - 0x01 -> 19 veces - 0x03 -> 19 veces - 0x08 -> 19 veces - -Offset 0x04B93 (19347): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 97 veces - 0x00 -> 88 veces - 0x02 -> 36 veces - 0x04 -> 10 veces - 0x03 -> 3 veces - -Offset 0x04B94 (19348): - Valores distintos (8): 0x00, 0x01, 0x02, 0x07, 0x08, 0x09, 0x0A, 0x1C - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x08 -> 41 veces - 0x1C -> 30 veces - 0x0A -> 25 veces - 0x07 -> 17 veces - -Offset 0x04B95 (19349): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x01 -> 71 veces - 0x02 -> 64 veces - 0x04 -> 11 veces - -Offset 0x04B96 (19350): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x23 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x03 -> 69 veces - 0x01 -> 34 veces - 0x02 -> 32 veces - 0x23 -> 11 veces - -Offset 0x04B97 (19351): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x01 -> 68 veces - 0x04 -> 44 veces - 0x02 -> 34 veces - -Offset 0x04B98 (19352): - Valores distintos (6): 0x00, 0x01, 0x02, 0x0A, 0x10, 0x54 - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x54 -> 72 veces - 0x02 -> 30 veces - 0x01 -> 14 veces - 0x0A -> 13 veces - -Offset 0x04B99 (19353): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x04 -> 72 veces - 0x01 -> 30 veces - 0x02 -> 28 veces - 0x03 -> 10 veces - -Offset 0x04B9A (19354): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 96 veces - 0x00 -> 94 veces - 0x02 -> 44 veces - -Offset 0x04B9B (19355): - Valores distintos (4): 0x00, 0x01, 0x02, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 94 veces - 0x02 -> 82 veces - 0x01 -> 47 veces - 0x0A -> 11 veces - -Offset 0x04B9C (19356): - Valores distintos (8): 0x00, 0x01, 0x02, 0x03, 0x04, 0x06, 0x07, 0x1D - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x04 -> 38 veces - 0x03 -> 34 veces - 0x07 -> 25 veces - 0x02 -> 14 veces - -Offset 0x04B9D (19357): - Valores distintos (4): 0x00, 0x01, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x01 -> 96 veces - 0x04 -> 30 veces - 0x03 -> 11 veces - -Offset 0x04B9E (19358): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x02 -> 34 veces - 0x01 -> 30 veces - 0x07 -> 19 veces - 0x04 -> 18 veces - -Offset 0x04B9F (19359): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x01 -> 102 veces - 0x04 -> 14 veces - 0x02 -> 11 veces - -Offset 0x04BA0 (19360): - Valores distintos (7): 0x00, 0x01, 0x03, 0x05, 0x07, 0x08, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x01 -> 44 veces - 0x08 -> 20 veces - 0x09 -> 19 veces - 0x07 -> 16 veces - -Offset 0x04BA1 (19361): - Valores distintos (4): 0x00, 0x01, 0x05, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x05 -> 72 veces - 0x01 -> 14 veces - 0x09 -> 11 veces - -Offset 0x04BA2 (19362): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 86 veces - 0x02 -> 11 veces - -Offset 0x04BA3 (19363): - Valores distintos (4): 0x00, 0x01, 0x02, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 47 veces - 0x02 -> 39 veces - 0x0A -> 11 veces - -Offset 0x04BA4 (19364): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 53 veces - 0x02 -> 30 veces - -Offset 0x04BA5 (19365): - Valores distintos (3): 0x00, 0x03, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x0A -> 72 veces - 0x03 -> 11 veces - -Offset 0x04BA6 (19366): - Valores distintos (3): 0x00, 0x01, 0x08 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x08 -> 72 veces - 0x01 -> 11 veces - -Offset 0x04BA7 (19367): - Valores distintos (5): 0x00, 0x02, 0x03, 0x04, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x04 -> 34 veces - 0x02 -> 16 veces - 0x09 -> 11 veces - 0x03 -> 5 veces - -Offset 0x04BA8 (19368): - Valores distintos (6): 0x00, 0x05, 0x1A, 0x1D, 0x1E, 0x21 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x21 -> 17 veces - 0x1A -> 14 veces - 0x05 -> 11 veces - 0x1D -> 6 veces - -Offset 0x04BA9 (19369): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 189 veces - 0x01 -> 45 veces - -Offset 0x04BAA (19370): - Valores distintos (3): 0x00, 0x04, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x04 -> 19 veces - 0x0A -> 11 veces - -Offset 0x04BAB (19371): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x09 -> 11 veces - -Offset 0x04BF4 (19444): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 191 veces - 0x00 -> 24 veces - 0x03 -> 19 veces - -Offset 0x04BF5 (19445): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 174 veces - 0x00 -> 30 veces - 0x03 -> 30 veces - -Offset 0x04BF6 (19446): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 154 veces - 0x00 -> 51 veces - 0x03 -> 29 veces - -Offset 0x04BF7 (19447): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 109 veces - 0x03 -> 72 veces - 0x00 -> 53 veces - -Offset 0x04BF8 (19448): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 101 veces - 0x00 -> 88 veces - 0x02 -> 45 veces - -Offset 0x04BF9 (19449): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x02 -> 85 veces - 0x01 -> 61 veces - -Offset 0x04BFA (19450): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 121 veces - 0x00 -> 88 veces - 0x02 -> 14 veces - 0x04 -> 11 veces - -Offset 0x04BFB (19451): - Valores distintos (4): 0x00, 0x01, 0x02, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x04 -> 72 veces - 0x02 -> 44 veces - 0x01 -> 30 veces - -Offset 0x04BFC (19452): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x01 -> 74 veces - 0x02 -> 72 veces - -Offset 0x04BFD (19453): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 146 veces - 0x00 -> 88 veces - -Offset 0x04BFE (19454): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 132 veces - 0x00 -> 88 veces - 0x03 -> 14 veces - -Offset 0x04BFF (19455): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x03 -> 72 veces - 0x01 -> 63 veces - 0x02 -> 11 veces - -Offset 0x04C00 (19456): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 146 veces - 0x00 -> 88 veces - -Offset 0x04C01 (19457): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 140 veces - 0x00 -> 94 veces - -Offset 0x04C02 (19458): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 140 veces - 0x00 -> 94 veces - -Offset 0x04C03 (19459): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 137 veces - 0x00 -> 97 veces - -Offset 0x04C04 (19460): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04C05 (19461): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x04C06 (19462): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x01 -> 69 veces - 0x03 -> 11 veces - -Offset 0x04C07 (19463): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 154 veces - 0x01 -> 80 veces - -Offset 0x04C08 (19464): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 156 veces - 0x01 -> 78 veces - -Offset 0x04C09 (19465): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 168 veces - 0x01 -> 66 veces - -Offset 0x04C0A (19466): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x01 -> 55 veces - 0x02 -> 11 veces - -Offset 0x04C0B (19467): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 168 veces - 0x01 -> 66 veces - -Offset 0x04C0C (19468): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 39 veces - 0x02 -> 11 veces - -Offset 0x04C0D (19469): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 50 veces - -Offset 0x04C0E (19470): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 50 veces - -Offset 0x04C0F (19471): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 50 veces - -Offset 0x04C10 (19472): - Valores distintos (3): 0x00, 0x01, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 39 veces - 0x04 -> 11 veces - -Offset 0x04C11 (19473): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 39 veces - 0x02 -> 11 veces - -Offset 0x04C12 (19474): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 185 veces - 0x01 -> 49 veces - -Offset 0x04C13 (19475): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 189 veces - 0x01 -> 45 veces - -Offset 0x04C14 (19476): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 25 veces - 0x03 -> 11 veces - -Offset 0x04C15 (19477): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x02 -> 19 veces - 0x01 -> 17 veces - -Offset 0x04C16 (19478): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x03 -> 17 veces - 0x01 -> 11 veces - 0x02 -> 2 veces - -Offset 0x04C17 (19479): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x04C18 (19480): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x04C19 (19481): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04C1A (19482): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04C1B (19483): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04C1C (19484): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04C1D (19485): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04C74 (19572): - Valores distintos (3): 0x00, 0x01, 0x04 - Clasificación: small_state - Más frecuentes: - 0x01 -> 186 veces - 0x00 -> 33 veces - 0x04 -> 15 veces - -Offset 0x04C75 (19573): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 174 veces - 0x00 -> 35 veces - 0x02 -> 25 veces - -Offset 0x04C76 (19574): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 129 veces - 0x00 -> 75 veces - 0x03 -> 30 veces - -Offset 0x04C77 (19575): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x02 -> 106 veces - 0x00 -> 51 veces - 0x01 -> 47 veces - 0x03 -> 30 veces - -Offset 0x04C78 (19576): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 122 veces - 0x00 -> 88 veces - 0x02 -> 24 veces - -Offset 0x04C79 (19577): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 108 veces - 0x01 -> 71 veces - 0x02 -> 55 veces - -Offset 0x04C7A (19578): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x02 -> 67 veces - 0x01 -> 45 veces - 0x03 -> 25 veces - -Offset 0x04C7B (19579): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 97 veces - 0x03 -> 14 veces - -Offset 0x04C7C (19580): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 101 veces - 0x00 -> 97 veces - 0x02 -> 36 veces - -Offset 0x04C7D (19581): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x03 -> 72 veces - 0x01 -> 41 veces - 0x02 -> 14 veces - -Offset 0x04C7E (19582): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x01 -> 102 veces - 0x03 -> 14 veces - 0x02 -> 11 veces - -Offset 0x04C7F (19583): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 132 veces - 0x02 -> 47 veces - 0x03 -> 39 veces - 0x01 -> 16 veces - -Offset 0x04C80 (19584): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x03 -> 72 veces - 0x01 -> 11 veces - -Offset 0x04C81 (19585): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x06 -> 39 veces - 0x02 -> 31 veces - 0x04 -> 16 veces - 0x01 -> 11 veces - -Offset 0x04C82 (19586): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x02 -> 72 veces - 0x01 -> 11 veces - -Offset 0x04C83 (19587): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x03 -> 72 veces - 0x01 -> 11 veces - -Offset 0x04C84 (19588): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 72 veces - 0x03 -> 11 veces - -Offset 0x04C85 (19589): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 154 veces - 0x01 -> 80 veces - -Offset 0x04C86 (19590): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x02 -> 39 veces - 0x01 -> 30 veces - 0x03 -> 11 veces - -Offset 0x04C87 (19591): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x01 -> 55 veces - 0x03 -> 11 veces - -Offset 0x04C88 (19592): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x06, 0x08 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x03 -> 25 veces - 0x02 -> 13 veces - 0x08 -> 7 veces - 0x06 -> 4 veces - -Offset 0x04C89 (19593): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 39 veces - 0x02 -> 11 veces - -Offset 0x04C8A (19594): - Valores distintos (4): 0x00, 0x01, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 185 veces - 0x01 -> 38 veces - 0x04 -> 7 veces - 0x03 -> 4 veces - -Offset 0x04C8B (19595): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 50 veces - -Offset 0x04C8C (19596): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 25 veces - 0x02 -> 11 veces - -Offset 0x04C8D (19597): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 19 veces - 0x03 -> 11 veces - -Offset 0x04C8E (19598): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x04C8F (19599): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x04C90 (19600): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x04C91 (19601): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x02 -> 11 veces - -Offset 0x04C92 (19602): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04C93 (19603): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04C94 (19604): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04CF4 (19700): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x0B - Clasificación: small_state - Más frecuentes: - 0x03 -> 89 veces - 0x02 -> 81 veces - 0x01 -> 38 veces - 0x00 -> 15 veces - 0x0B -> 11 veces - -Offset 0x04CF5 (19701): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 186 veces - 0x00 -> 26 veces - 0x03 -> 22 veces - -Offset 0x04CF6 (19702): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0x05 - Clasificación: small_state - Más frecuentes: - 0x01 -> 127 veces - 0x03 -> 41 veces - 0x00 -> 35 veces - 0x05 -> 26 veces - 0x02 -> 5 veces - -Offset 0x04CF7 (19703): - Valores distintos (4): 0x00, 0x01, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x01 -> 171 veces - 0x00 -> 35 veces - 0x02 -> 21 veces - 0x03 -> 7 veces - -Offset 0x04CF8 (19704): - Valores distintos (4): 0x00, 0x01, 0x05, 0x09 - Clasificación: small_state - Más frecuentes: - 0x01 -> 140 veces - 0x00 -> 57 veces - 0x09 -> 22 veces - 0x05 -> 15 veces - -Offset 0x04CF9 (19705): - Valores distintos (4): 0x00, 0x01, 0x03, 0x06 - Clasificación: small_state - Más frecuentes: - 0x01 -> 97 veces - 0x00 -> 70 veces - 0x03 -> 37 veces - 0x06 -> 30 veces - -Offset 0x04CFA (19706): - Valores distintos (7): 0x00, 0x01, 0x02, 0x06, 0x07, 0x14, 0x15 - Clasificación: small_state - Más frecuentes: - 0x00 -> 51 veces - 0x01 -> 51 veces - 0x15 -> 47 veces - 0x06 -> 30 veces - 0x14 -> 25 veces - -Offset 0x04CFB (19707): - Valores distintos (5): 0x00, 0x01, 0x03, 0x07, 0x15 - Clasificación: small_state - Más frecuentes: - 0x15 -> 86 veces - 0x00 -> 51 veces - 0x01 -> 48 veces - 0x07 -> 43 veces - 0x03 -> 6 veces - -Offset 0x04CFC (19708): - Valores distintos (5): 0x00, 0x01, 0x04, 0x05, 0x14 - Clasificación: small_state - Más frecuentes: - 0x14 -> 86 veces - 0x00 -> 66 veces - 0x04 -> 30 veces - 0x05 -> 30 veces - 0x01 -> 22 veces - -Offset 0x04CFD (19709): - Valores distintos (5): 0x00, 0x01, 0x02, 0x11, 0x14 - Clasificación: small_state - Más frecuentes: - 0x11 -> 72 veces - 0x01 -> 71 veces - 0x00 -> 66 veces - 0x14 -> 14 veces - 0x02 -> 11 veces - -Offset 0x04CFE (19710): - Valores distintos (5): 0x00, 0x01, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x01 -> 72 veces - 0x07 -> 49 veces - 0x05 -> 14 veces - 0x04 -> 11 veces - -Offset 0x04CFF (19711): - Valores distintos (5): 0x00, 0x01, 0x03, 0x07, 0x0D - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x07 -> 72 veces - 0x0D -> 43 veces - 0x01 -> 25 veces - 0x03 -> 6 veces - -Offset 0x04D00 (19712): - Valores distintos (5): 0x00, 0x07, 0x13, 0x14, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 99 veces - 0x16 -> 49 veces - 0x14 -> 42 veces - 0x13 -> 30 veces - 0x07 -> 14 veces - -Offset 0x04D01 (19713): - Valores distintos (4): 0x00, 0x03, 0x14, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x16 -> 72 veces - 0x03 -> 49 veces - 0x14 -> 25 veces - -Offset 0x04D02 (19714): - Valores distintos (5): 0x00, 0x05, 0x14, 0x15, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x05 -> 72 veces - 0x14 -> 49 veces - 0x16 -> 14 veces - 0x15 -> 11 veces - -Offset 0x04D03 (19715): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 88 veces - 0x14 -> 83 veces - 0x02 -> 30 veces - 0x01 -> 19 veces - 0x04 -> 14 veces - -Offset 0x04D04 (19716): - Valores distintos (5): 0x00, 0x01, 0x0B, 0x11, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x0B -> 72 veces - 0x01 -> 30 veces - 0x14 -> 14 veces - 0x11 -> 11 veces - -Offset 0x04D05 (19717): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x01 -> 113 veces - 0x00 -> 107 veces - 0x02 -> 14 veces - -Offset 0x04D06 (19718): - Valores distintos (3): 0x00, 0x01, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 86 veces - 0x07 -> 11 veces - -Offset 0x04D07 (19719): - Valores distintos (5): 0x00, 0x01, 0x11, 0x13, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x14 -> 41 veces - 0x11 -> 25 veces - 0x13 -> 17 veces - 0x01 -> 14 veces - -Offset 0x04D08 (19720): - Valores distintos (4): 0x00, 0x08, 0x09, 0x16 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x09 -> 55 veces - 0x08 -> 17 veces - 0x16 -> 11 veces - -Offset 0x04D09 (19721): - Valores distintos (4): 0x00, 0x01, 0x02, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 53 veces - 0x02 -> 19 veces - 0x05 -> 11 veces - -Offset 0x04D0A (19722): - Valores distintos (3): 0x00, 0x01, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 72 veces - 0x14 -> 11 veces - -Offset 0x04D0B (19723): - Valores distintos (3): 0x00, 0x01, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 163 veces - 0x01 -> 60 veces - 0x0B -> 11 veces - -Offset 0x04D0C (19724): - Valores distintos (3): 0x00, 0x01, 0x11 - Clasificación: small_state - Más frecuentes: - 0x00 -> 163 veces - 0x01 -> 60 veces - 0x11 -> 11 veces - -Offset 0x04D0D (19725): - Valores distintos (3): 0x00, 0x01, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0x01 -> 34 veces - 0x09 -> 11 veces - -Offset 0x04D0E (19726): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 189 veces - 0x01 -> 26 veces - 0x02 -> 19 veces - -Offset 0x04D0F (19727): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x04D10 (19728): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x04D11 (19729): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x04D12 (19730): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x04D13 (19731): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04D14 (19732): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04D15 (19733): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04D16 (19734): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x02 -> 11 veces - -Offset 0x04D17 (19735): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x02 -> 11 veces - -Offset 0x04D74 (19828): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x03 -> 205 veces - 0x00 -> 29 veces - -Offset 0x04D75 (19829): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x01 -> 190 veces - 0x00 -> 44 veces - -Offset 0x04D76 (19830): - Valores distintos (3): 0x00, 0x04, 0x0E - Clasificación: small_state - Más frecuentes: - 0x04 -> 106 veces - 0x00 -> 88 veces - 0x0E -> 40 veces - -Offset 0x04D77 (19831): - Valores distintos (2): 0x00, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 146 veces - 0x00 -> 88 veces - -Offset 0x04D78 (19832): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x05 -> 140 veces - 0x00 -> 94 veces - -Offset 0x04D79 (19833): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x09 -> 97 veces - -Offset 0x04D7A (19834): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x0A -> 83 veces - -Offset 0x04D7B (19835): - Valores distintos (2): 0x00, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x06 -> 80 veces - -Offset 0x04D7C (19836): - Valores distintos (2): 0x00, 0x0D - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x0D -> 30 veces - -Offset 0x04D7D (19837): - Valores distintos (2): 0x00, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x0C -> 11 veces - -Offset 0x04D94 (19860): - Valores distintos (3): 0x00, 0x3E, 0x45 - Clasificación: small_state - Más frecuentes: - 0x00 -> 140 veces - 0x45 -> 83 veces - 0x3E -> 11 veces - -Offset 0x04D95 (19861): - Valores distintos (2): 0x00, 0x14 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x14 -> 11 veces - -Offset 0x04D96 (19862): - Valores distintos (2): 0x00, 0xAA - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xAA -> 11 veces - -Offset 0x04D97 (19863): - Valores distintos (2): 0x00, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x0F -> 11 veces - -Offset 0x04D98 (19864): - Valores distintos (2): 0x00, 0xA3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xA3 -> 11 veces - -Offset 0x04D99 (19865): - Valores distintos (2): 0x00, 0xC4 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xC4 -> 11 veces - -Offset 0x04D9A (19866): - Valores distintos (2): 0x00, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x0A -> 11 veces - -Offset 0x04D9B (19867): - Valores distintos (2): 0x00, 0xA4 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0xA4 -> 11 veces - -Offset 0x04D9C (19868): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x00 -> 223 veces - 0x10 -> 11 veces - -Offset 0x04E14 (19988): - Valores distintos (5): 0x00, 0x01, 0x05, 0x06, 0x08 - Clasificación: small_state - Más frecuentes: - 0x06 -> 91 veces - 0x01 -> 59 veces - 0x08 -> 36 veces - 0x00 -> 29 veces - 0x05 -> 19 veces - -Offset 0x04E1A (19994): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 124 veces - 0x02 -> 74 veces - 0x01 -> 36 veces - -Offset 0x04E1B (19995): - Valores distintos (2): 0x00, 0x1E - Clasificación: small_state - Más frecuentes: - 0x1E -> 146 veces - 0x00 -> 88 veces - -Offset 0x04E1C (19996): - Valores distintos (3): 0x00, 0x02, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 154 veces - 0x02 -> 79 veces - 0x03 -> 1 veces - -Offset 0x04E1E (19998): - Valores distintos (2): 0x00, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 215 veces - 0x04 -> 19 veces - -Offset 0x04E1F (19999): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 171 veces - 0x02 -> 43 veces - 0x01 -> 20 veces - -Offset 0x04E21 (20001): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0x03 -> 31 veces - 0x01 -> 12 veces - -Offset 0x04E22 (20002): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 161 veces - 0x02 -> 59 veces - 0x01 -> 14 veces - -Offset 0x04E23 (20003): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 228 veces - 0x02 -> 6 veces - -Offset 0x04E24 (20004): - Valores distintos (3): 0x00, 0x01, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 191 veces - 0x01 -> 37 veces - 0x06 -> 6 veces - -Offset 0x04E26 (20006): - Valores distintos (6): 0x00, 0x03, 0x05, 0x0A, 0x0E, 0x1C - Clasificación: small_state - Más frecuentes: - 0x00 -> 130 veces - 0x1C -> 47 veces - 0x03 -> 29 veces - 0x0A -> 15 veces - 0x0E -> 11 veces - -Offset 0x04E27 (20007): - Valores distintos (8): 0x00, 0x03, 0x04, 0x05, 0x09, 0x0D, 0x14, 0x20 - Clasificación: small_state - Más frecuentes: - 0x03 -> 51 veces - 0x00 -> 49 veces - 0x20 -> 47 veces - 0x05 -> 40 veces - 0x04 -> 19 veces - -Offset 0x04E28 (20008): - Valores distintos (6): 0x00, 0x01, 0x02, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 89 veces - 0x11 -> 45 veces - 0xFF -> 44 veces - 0x01 -> 25 veces - 0x09 -> 19 veces - -Offset 0x04E29 (20009): - Valores distintos (6): 0x05, 0x06, 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 85 veces - 0xFF -> 77 veces - 0x0E -> 34 veces - 0x09 -> 21 veces - 0x05 -> 12 veces - -Offset 0x04E2A (20010): - Valores distintos (6): 0x04, 0x05, 0x06, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 142 veces - 0x04 -> 34 veces - 0x0A -> 26 veces - 0x05 -> 19 veces - 0x09 -> 12 veces - -Offset 0x04E2B (20011): - Valores distintos (8): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 67 veces - 0xFF -> 44 veces - 0x04 -> 34 veces - 0x41 -> 25 veces - 0x20 -> 22 veces - -Offset 0x04E2C (20012): - Valores distintos (6): 0x00, 0x01, 0x02, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 75 veces - 0xFF -> 44 veces - 0x01 -> 43 veces - 0x11 -> 36 veces - 0x02 -> 24 veces - -Offset 0x04E2D (20013): - Valores distintos (6): 0x05, 0x06, 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 73 veces - 0x0A -> 51 veces - 0x0E -> 36 veces - 0x09 -> 28 veces - 0x06 -> 25 veces - -Offset 0x04E2E (20014): - Valores distintos (6): 0x04, 0x05, 0x06, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 107 veces - 0x0A -> 53 veces - 0x04 -> 36 veces - 0x09 -> 21 veces - 0x05 -> 12 veces - -Offset 0x04E2F (20015): - Valores distintos (8): 0x02, 0x04, 0x20, 0x21, 0x41, 0x61, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 46 veces - 0xFF -> 44 veces - 0x41 -> 43 veces - 0x04 -> 36 veces - 0x20 -> 29 veces - -Offset 0x04E30 (20016): - Valores distintos (6): 0x00, 0x01, 0x02, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 71 veces - 0xFF -> 51 veces - 0x01 -> 46 veces - 0x11 -> 36 veces - 0x09 -> 21 veces - -Offset 0x04E31 (20017): - Valores distintos (5): 0x05, 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 111 veces - 0xFF -> 77 veces - 0x0E -> 25 veces - 0x09 -> 12 veces - 0x05 -> 9 veces - -Offset 0x04E32 (20018): - Valores distintos (5): 0x04, 0x05, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 167 veces - 0x04 -> 25 veces - 0x05 -> 21 veces - 0x0A -> 12 veces - 0x09 -> 9 veces - -Offset 0x04E33 (20019): - Valores distintos (8): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 56 veces - 0xFF -> 51 veces - 0x41 -> 46 veces - 0x04 -> 25 veces - 0x02 -> 21 veces - -Offset 0x04E34 (20020): - Valores distintos (6): 0x00, 0x01, 0x02, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 85 veces - 0xFF -> 51 veces - 0x00 -> 43 veces - 0x11 -> 36 veces - 0x02 -> 10 veces - -Offset 0x04E35 (20021): - Valores distintos (4): 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 100 veces - 0x0A -> 88 veces - 0x0E -> 25 veces - 0x09 -> 21 veces - -Offset 0x04E36 (20022): - Valores distintos (5): 0x04, 0x05, 0x06, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 176 veces - 0x04 -> 25 veces - 0x0A -> 21 veces - 0x05 -> 9 veces - 0x06 -> 3 veces - -Offset 0x04E37 (20023): - Valores distintos (8): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 85 veces - 0xFF -> 51 veces - 0x20 -> 38 veces - 0x04 -> 25 veces - 0x08 -> 11 veces - -Offset 0x04E38 (20024): - Valores distintos (5): 0x00, 0x01, 0x02, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 86 veces - 0xFF -> 66 veces - 0x00 -> 41 veces - 0x11 -> 36 veces - 0x02 -> 5 veces - -Offset 0x04E39 (20025): - Valores distintos (4): 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 104 veces - 0x0A -> 96 veces - 0x0E -> 25 veces - 0x09 -> 9 veces - -Offset 0x04E3A (20026): - Valores distintos (3): 0x04, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 200 veces - 0x04 -> 25 veces - 0x0A -> 9 veces - -Offset 0x04E3B (20027): - Valores distintos (7): 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 86 veces - 0xFF -> 66 veces - 0x20 -> 27 veces - 0x04 -> 25 veces - 0x21 -> 14 veces - -Offset 0x04E3C (20028): - Valores distintos (5): 0x00, 0x01, 0x02, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 88 veces - 0x01 -> 71 veces - 0x11 -> 36 veces - 0x02 -> 25 veces - 0x00 -> 14 veces - -Offset 0x04E3D (20029): - Valores distintos (3): 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 109 veces - 0xFF -> 100 veces - 0x0E -> 25 veces - -Offset 0x04E3E (20030): - Valores distintos (3): 0x04, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 199 veces - 0x04 -> 25 veces - 0x06 -> 10 veces - -Offset 0x04E3F (20031): - Valores distintos (7): 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 88 veces - 0x41 -> 71 veces - 0x61 -> 25 veces - 0x04 -> 25 veces - 0x21 -> 13 veces - -Offset 0x04E40 (20032): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 146 veces - 0xFF -> 88 veces - -Offset 0x04E41 (20033): - Valores distintos (2): 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 146 veces - 0xFF -> 88 veces - -Offset 0x04E43 (20035): - Valores distintos (2): 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 146 veces - 0xFF -> 88 veces - -Offset 0x04E44 (20036): - Valores distintos (2): 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 198 veces - 0x11 -> 36 veces - -Offset 0x04E45 (20037): - Valores distintos (2): 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 198 veces - 0x0E -> 36 veces - -Offset 0x04E46 (20038): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 198 veces - 0x04 -> 36 veces - -Offset 0x04E47 (20039): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 198 veces - 0x04 -> 36 veces - -Offset 0x04E70 (20080): - Valores distintos (8): 0x00, 0x01, 0x41, 0x47, 0xC7, 0xCF, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 66 veces - 0xEF -> 56 veces - 0x41 -> 44 veces - 0x00 -> 29 veces - 0x01 -> 15 veces - -Offset 0x04E71 (20081): - Valores distintos (7): 0x00, 0x08, 0x0C, 0x0D, 0x3F, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 50 veces - 0x00 -> 44 veces - 0x0C -> 43 veces - 0x0D -> 43 veces - 0x3F -> 31 veces - -Offset 0x04E72 (20082): - Valores distintos (3): 0x00, 0x01, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 97 veces - 0x01 -> 87 veces - 0x03 -> 50 veces - -Offset 0x04E74 (20084): - Valores distintos (7): 0x00, 0x03, 0x23, 0x27, 0x77, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 127 veces - 0x00 -> 29 veces - 0x23 -> 22 veces - 0x27 -> 22 veces - 0x03 -> 15 veces - -Offset 0x04E75 (20085): - Valores distintos (6): 0x00, 0x01, 0x07, 0x1F, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0xFF -> 50 veces - 0x01 -> 30 veces - 0x1F -> 17 veces - 0x7F -> 16 veces - -Offset 0x04E76 (20086): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04E77 (20087): - Valores distintos (8): 0x00, 0x03, 0x23, 0x27, 0x37, 0xB7, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBF -> 91 veces - 0xFF -> 36 veces - 0x00 -> 29 veces - 0x23 -> 22 veces - 0x27 -> 22 veces - -Offset 0x04E78 (20088): - Valores distintos (6): 0x00, 0x01, 0x0B, 0x6B, 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 107 veces - 0x01 -> 44 veces - 0xFF -> 36 veces - 0x0B -> 17 veces - 0x6B -> 16 veces - -Offset 0x04E79 (20089): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 30 veces - -Offset 0x04EA5 (20133): - Valores distintos (5): 0x00, 0x01, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x07 -> 112 veces - 0x00 -> 82 veces - 0x05 -> 31 veces - 0x01 -> 7 veces - 0x04 -> 2 veces - -Offset 0x04EA6 (20134): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0x0B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x05 -> 41 veces - 0x02 -> 40 veces - 0x0B -> 38 veces - 0x01 -> 25 veces - 0x07 -> 25 veces - -Offset 0x04EA7 (20135): - Valores distintos (10): 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x0B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x05 -> 50 veces - 0x0B -> 50 veces - 0x02 -> 34 veces - 0xFF -> 25 veces - 0x04 -> 18 veces - -Offset 0x04EA8 (20136): - Valores distintos (25): 0x03, 0x04, 0x06, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x14, 0x15, 0x16, 0x18, 0x19, 0x1A, 0x1E, 0x1F, 0x20, 0x22, 0x24, 0x25, 0x26, 0x2A, 0x2E, 0x2F, 0x34 - Clasificación: bitfield_like - Más frecuentes: - 0x1A -> 25 veces - 0x14 -> 22 veces - 0x06 -> 21 veces - 0x2F -> 17 veces - 0x22 -> 16 veces - -Offset 0x04EAC (20140): - Valores distintos (26): 0x00, 0x01, 0x02, 0x06, 0x07, 0x09, 0x0A, 0x0D, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x21, 0x25, 0x26, 0x27, 0x2A, 0x2E, 0x2F, 0x30, 0x34, 0x3B, 0x3C, 0x45, 0x46 - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 25 veces - 0x0D -> 22 veces - 0x02 -> 18 veces - 0x3C -> 17 veces - 0x2A -> 16 veces - -Offset 0x04EAD (20141): - Valores distintos (29): 0x00, 0x02, 0x04, 0x06, 0x08, 0x09, 0x0B, 0x0D, 0x11, 0x13, 0x14, 0x16, 0x18, 0x19, 0x1A, 0x1C, 0x24, 0x25, 0x26, 0x27, 0x28, 0x2A, 0x2B, 0x30, 0x31, 0x33, 0x34, 0x36, 0x38 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 25 veces - 0x08 -> 24 veces - 0x18 -> 20 veces - 0x25 -> 17 veces - 0x24 -> 16 veces - -Offset 0x04EAE (20142): - Valores distintos (24): 0x00, 0x01, 0x06, 0x08, 0x09, 0x0B, 0x0C, 0x0D, 0x0E, 0x11, 0x12, 0x15, 0x19, 0x1B, 0x1E, 0x21, 0x23, 0x27, 0x2A, 0x31, 0x32, 0x33, 0x36, 0x39 - Clasificación: bitfield_like - Más frecuentes: - 0x11 -> 34 veces - 0x2A -> 31 veces - 0x01 -> 25 veces - 0x1E -> 20 veces - 0x21 -> 18 veces - -Offset 0x04EAF (20143): - Valores distintos (20): 0x01, 0x03, 0x05, 0x07, 0x08, 0x09, 0x0C, 0x0E, 0x0F, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18, 0x1A, 0x1B, 0x1C, 0x1D - Clasificación: bitfield_like - Más frecuentes: - 0x16 -> 40 veces - 0x0C -> 28 veces - 0x12 -> 25 veces - 0x0F -> 20 veces - 0x1C -> 16 veces - -Offset 0x04EB0 (20144): - Valores distintos (32): 0x03, 0x06, 0x0C, 0x0D, 0x0F, 0x21, 0x2A, 0x30, 0x46, 0x48, 0x4C, 0x5D, 0x63, 0x6C, 0x75, 0x80, 0x93, 0x96, 0x98, 0x9B, 0x9E, 0xBD, 0xC3, 0xC7, 0xCE, 0xD0, 0xD2, 0xE2, 0xEA, 0xEE, 0xF6, 0xF7 - Clasificación: bitfield_like - Más frecuentes: - 0x0C -> 31 veces - 0x98 -> 25 veces - 0x96 -> 20 veces - 0x0D -> 18 veces - 0xF6 -> 16 veces - -Offset 0x04EB1 (20145): - Valores distintos (27): 0x00, 0x01, 0x02, 0x09, 0x0C, 0x10, 0x13, 0x14, 0x19, 0x2B, 0x2C, 0x35, 0x37, 0x39, 0x3C, 0x42, 0x51, 0x65, 0x66, 0x73, 0x7C, 0xAE, 0xC1, 0xDE, 0xE3, 0xF0, 0xFB - Clasificación: bitfield_like - Más frecuentes: - 0x73 -> 25 veces - 0x2C -> 20 veces - 0x65 -> 19 veces - 0x01 -> 18 veces - 0x37 -> 16 veces - -Offset 0x04EB2 (20146): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x01 -> 21 veces - 0x06 -> 17 veces - 0x0A -> 11 veces - 0x02 -> 9 veces - -Offset 0x04EB4 (20148): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 223 veces - 0x01 -> 11 veces - -Offset 0x04ED0 (20176): - Valores distintos (5): 0x00, 0x03, 0x09, 0x21, 0x2A - Clasificación: small_state - Más frecuentes: - 0x00 -> 203 veces - 0x03 -> 14 veces - 0x2A -> 9 veces - 0x21 -> 5 veces - 0x09 -> 3 veces - -Offset 0x04ED4 (20180): - Valores distintos (3): 0x00, 0x38, 0x85 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x85 -> 83 veces - 0x38 -> 14 veces - -Offset 0x04ED5 (20181): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 97 veces - -Offset 0x04ED8 (20184): - Valores distintos (10): 0x00, 0x05, 0x24, 0x66, 0x68, 0x8D, 0x92, 0x9C, 0xBA, 0xCC - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 137 veces - 0x8D -> 19 veces - 0x05 -> 16 veces - 0x24 -> 14 veces - 0x66 -> 11 veces - -Offset 0x04ED9 (20185): - Valores distintos (5): 0x00, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 36 veces - 0x03 -> 31 veces - 0x05 -> 19 veces - 0x07 -> 11 veces - -Offset 0x04EDC (20188): - Valores distintos (10): 0x00, 0x19, 0x38, 0x7A, 0x7C, 0xA1, 0xA6, 0xB0, 0xCE, 0xE0 - Clasificación: bitfield_like - Más frecuentes: - 0x00 -> 137 veces - 0xA1 -> 19 veces - 0x19 -> 16 veces - 0x38 -> 14 veces - 0x7A -> 11 veces - -Offset 0x04EDD (20189): - Valores distintos (5): 0x00, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 36 veces - 0x03 -> 31 veces - 0x05 -> 19 veces - 0x07 -> 11 veces - -Offset 0x04EE0 (20192): - Valores distintos (6): 0x00, 0x52, 0x5A, 0x5B, 0x5D, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x70 -> 50 veces - 0x5D -> 16 veces - 0x52 -> 14 veces - 0x5B -> 10 veces - -Offset 0x04EE1 (20193): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 97 veces - -Offset 0x04EE4 (20196): - Valores distintos (6): 0x00, 0x52, 0x8F, 0x99, 0xAD, 0xE3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xE3 -> 50 veces - 0xAD -> 16 veces - 0x52 -> 14 veces - 0x99 -> 10 veces - -Offset 0x04EE5 (20197): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 97 veces - -Offset 0x04EE8 (20200): - Valores distintos (5): 0x00, 0xB2, 0xB4, 0xB5, 0xB9 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xB5 -> 40 veces - 0xB9 -> 36 veces - 0xB2 -> 14 veces - 0xB4 -> 7 veces - -Offset 0x04EEA (20202): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x63 -> 97 veces - -Offset 0x04EEB (20203): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x05, 0x0A - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x0A -> 50 veces - 0x05 -> 16 veces - 0x01 -> 14 veces - 0x03 -> 10 veces - -Offset 0x04EEC (20204): - Valores distintos (5): 0x00, 0x02, 0x03, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x07 -> 50 veces - 0x05 -> 16 veces - 0x03 -> 10 veces - 0x02 -> 7 veces - -Offset 0x04EED (20205): - Valores distintos (3): 0x00, 0x05, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 211 veces - 0x05 -> 14 veces - 0x0F -> 9 veces - -Offset 0x04EEE (20206): - Valores distintos (5): 0x00, 0x04, 0x08, 0x09, 0x0F - Clasificación: small_state - Más frecuentes: - 0x00 -> 202 veces - 0x04 -> 14 veces - 0x09 -> 7 veces - 0x08 -> 6 veces - 0x0F -> 5 veces - -Offset 0x04EF8 (20216): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04EF9 (20217): - Valores distintos (4): 0x00, 0x01, 0x04, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 50 veces - 0x01 -> 33 veces - 0x0B -> 14 veces - -Offset 0x04EFC (20220): - Valores distintos (5): 0x00, 0x26, 0x38, 0x58, 0x5B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x58 -> 33 veces - 0x26 -> 30 veces - 0x5B -> 20 veces - 0x38 -> 14 veces - -Offset 0x04EFD (20221): - Valores distintos (4): 0x00, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 47 veces - 0x05 -> 30 veces - 0x04 -> 20 veces - -Offset 0x04F38 (20280): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x04F39 (20281): - Valores distintos (3): 0x00, 0x02, 0x06 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x02 -> 47 veces - 0x06 -> 36 veces - -Offset 0x04F3C (20284): - Valores distintos (4): 0x00, 0x7C, 0x85, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xE0 -> 36 veces - 0x85 -> 33 veces - 0x7C -> 14 veces - -Offset 0x04F3D (20285): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x04 -> 50 veces - 0x03 -> 33 veces - -Offset 0x04F48 (20296): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04F49 (20297): - Valores distintos (5): 0x00, 0x03, 0x07, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x07 -> 36 veces - 0x03 -> 33 veces - 0x0B -> 19 veces - 0x0A -> 9 veces - -Offset 0x04F4C (20300): - Valores distintos (6): 0x00, 0x7C, 0x85, 0xA6, 0xE0, 0xFA - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xE0 -> 36 veces - 0x85 -> 33 veces - 0xFA -> 14 veces - 0xA6 -> 9 veces - -Offset 0x04F4D (20301): - Valores distintos (4): 0x00, 0x02, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 50 veces - 0x03 -> 33 veces - 0x02 -> 14 veces - -Offset 0x04F88 (20360): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04F89 (20361): - Valores distintos (3): 0x00, 0x02, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x02 -> 83 veces - 0x09 -> 14 veces - -Offset 0x04F8C (20364): - Valores distintos (4): 0x00, 0x38, 0x7C, 0x85 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x7C -> 50 veces - 0x85 -> 33 veces - 0x38 -> 14 veces - -Offset 0x04F8D (20365): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 50 veces - 0x03 -> 47 veces - -Offset 0x04FA8 (20392): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04FA9 (20393): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x09 -> 97 veces - -Offset 0x04FAC (20396): - Valores distintos (2): 0x00, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x38 -> 97 veces - -Offset 0x04FAD (20397): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 97 veces - -Offset 0x04FB0 (20400): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04FB1 (20401): - Valores distintos (4): 0x00, 0x02, 0x03, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 50 veces - 0x02 -> 33 veces - 0x09 -> 14 veces - -Offset 0x04FB4 (20404): - Valores distintos (4): 0x00, 0x38, 0x5B, 0x85 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x5B -> 50 veces - 0x85 -> 33 veces - 0x38 -> 14 veces - -Offset 0x04FB5 (20405): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 50 veces - 0x03 -> 47 veces - -Offset 0x04FB8 (20408): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x04FB9 (20409): - Valores distintos (5): 0x00, 0x04, 0x08, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x08 -> 36 veces - 0x04 -> 26 veces - 0x0B -> 12 veces - 0x0A -> 9 veces - -Offset 0x04FBA (20410): - Valores distintos (2): 0x00, 0x28 - Clasificación: small_state - Más frecuentes: - 0x00 -> 228 veces - 0x28 -> 6 veces - -Offset 0x04FBB (20411): - Valores distintos (2): 0x00, 0x10 - Clasificación: small_state - Más frecuentes: - 0x00 -> 228 veces - 0x10 -> 6 veces - -Offset 0x04FBC (20412): - Valores distintos (8): 0x00, 0x26, 0x7A, 0x7C, 0xA6, 0xB0, 0xCE, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xCE -> 26 veces - 0x26 -> 19 veces - 0x7A -> 11 veces - 0xA6 -> 9 veces - -Offset 0x04FBD (20413): - Valores distintos (5): 0x00, 0x03, 0x04, 0x05, 0x07 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x03 -> 33 veces - 0x04 -> 20 veces - 0x05 -> 19 veces - 0x07 -> 11 veces - -Offset 0x04FC0 (20416): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04FC1 (20417): - Valores distintos (6): 0x00, 0x03, 0x07, 0x09, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 33 veces - 0x07 -> 30 veces - 0x09 -> 14 veces - 0x0B -> 11 veces - -Offset 0x04FC4 (20420): - Valores distintos (7): 0x00, 0x26, 0x7C, 0x85, 0xA6, 0xBF, 0xD3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x85 -> 33 veces - 0x26 -> 30 veces - 0xD3 -> 14 veces - 0xA6 -> 9 veces - -Offset 0x04FC5 (20421): - Valores distintos (5): 0x00, 0x02, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 33 veces - 0x05 -> 30 veces - 0x04 -> 20 veces - 0x02 -> 14 veces - -Offset 0x04FC8 (20424): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x04FC9 (20425): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x09 -> 97 veces - -Offset 0x04FCC (20428): - Valores distintos (2): 0x00, 0xAD - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xAD -> 97 veces - -Offset 0x04FCD (20429): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x02 -> 97 veces - -Offset 0x05000 (20480): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x05001 (20481): - Valores distintos (4): 0x00, 0x01, 0x03, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 50 veces - 0x03 -> 33 veces - 0x0B -> 14 veces - -Offset 0x05004 (20484): - Valores distintos (4): 0x00, 0x35, 0x38, 0x85 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x35 -> 50 veces - 0x85 -> 33 veces - 0x38 -> 14 veces - -Offset 0x05005 (20485): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 50 veces - 0x03 -> 47 veces - -Offset 0x05008 (20488): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x05009 (20489): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x09 -> 97 veces - -Offset 0x0500C (20492): - Valores distintos (2): 0x00, 0x38 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x38 -> 97 veces - -Offset 0x0500D (20493): - Valores distintos (2): 0x00, 0x03 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 97 veces - -Offset 0x05048 (20552): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x05049 (20553): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x09 -> 97 veces - -Offset 0x0504C (20556): - Valores distintos (2): 0x00, 0xAD - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xAD -> 97 veces - -Offset 0x0504D (20557): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x02 -> 97 veces - -Offset 0x05078 (20600): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x05079 (20601): - Valores distintos (5): 0x00, 0x04, 0x06, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x06 -> 30 veces - 0x04 -> 26 veces - 0x0A -> 23 veces - 0x0B -> 18 veces - -Offset 0x0507C (20604): - Valores distintos (8): 0x00, 0x26, 0x7C, 0xA6, 0xB0, 0xBF, 0xCE, 0xD3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x26 -> 30 veces - 0xCE -> 26 veces - 0xD3 -> 14 veces - 0xA6 -> 9 veces - -Offset 0x0507D (20605): - Valores distintos (5): 0x00, 0x02, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 33 veces - 0x05 -> 30 veces - 0x04 -> 20 veces - 0x02 -> 14 veces - -Offset 0x05080 (20608): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x05081 (20609): - Valores distintos (4): 0x00, 0x04, 0x05, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 50 veces - 0x09 -> 31 veces - 0x05 -> 16 veces - -Offset 0x05084 (20612): - Valores distintos (5): 0x00, 0x19, 0x26, 0x7C, 0xD3 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xD3 -> 31 veces - 0x26 -> 30 veces - 0x7C -> 20 veces - 0x19 -> 16 veces - -Offset 0x05085 (20613): - Valores distintos (4): 0x00, 0x02, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x04 -> 36 veces - 0x02 -> 31 veces - 0x05 -> 30 veces - -Offset 0x05088 (20616): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x05089 (20617): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x09 -> 97 veces - -Offset 0x0508C (20620): - Valores distintos (2): 0x00, 0xFA - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFA -> 97 veces - -Offset 0x0508D (20621): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x02 -> 97 veces - -Offset 0x05090 (20624): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x05091 (20625): - Valores distintos (5): 0x00, 0x03, 0x04, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 30 veces - 0x04 -> 26 veces - 0x0A -> 23 veces - 0x0B -> 18 veces - -Offset 0x05094 (20628): - Valores distintos (8): 0x00, 0x26, 0x7C, 0xA6, 0xAD, 0xB0, 0xBF, 0xCE - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x26 -> 30 veces - 0xCE -> 26 veces - 0xAD -> 14 veces - 0xA6 -> 9 veces - -Offset 0x05095 (20629): - Valores distintos (5): 0x00, 0x02, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x03 -> 33 veces - 0x05 -> 30 veces - 0x04 -> 20 veces - 0x02 -> 14 veces - -Offset 0x05098 (20632): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x05099 (20633): - Valores distintos (3): 0x00, 0x01, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x05 -> 50 veces - 0x01 -> 33 veces - -Offset 0x0509C (20636): - Valores distintos (3): 0x00, 0x35, 0x58 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x35 -> 50 veces - 0x58 -> 33 veces - -Offset 0x0509D (20637): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x04 -> 50 veces - 0x03 -> 33 veces - -Offset 0x050A0 (20640): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x050A1 (20641): - Valores distintos (5): 0x00, 0x02, 0x05, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x02 -> 30 veces - 0x05 -> 26 veces - 0x0B -> 18 veces - 0x0A -> 9 veces - -Offset 0x050A4 (20644): - Valores distintos (7): 0x00, 0x26, 0x7C, 0xA6, 0xB0, 0xBF, 0xCE - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x26 -> 30 veces - 0xCE -> 26 veces - 0xA6 -> 9 veces - 0xB0 -> 7 veces - -Offset 0x050A5 (20645): - Valores distintos (4): 0x00, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x03 -> 33 veces - 0x05 -> 30 veces - 0x04 -> 20 veces - -Offset 0x050A8 (20648): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 137 veces - 0x01 -> 97 veces - -Offset 0x050A9 (20649): - Valores distintos (2): 0x00, 0x09 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x09 -> 97 veces - -Offset 0x050AC (20652): - Valores distintos (2): 0x00, 0xFA - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFA -> 97 veces - -Offset 0x050AD (20653): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x02 -> 97 veces - -Offset 0x050B0 (20656): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 151 veces - 0x01 -> 83 veces - -Offset 0x050B1 (20657): - Valores distintos (3): 0x00, 0x01, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x04 -> 50 veces - 0x01 -> 33 veces - -Offset 0x050B4 (20660): - Valores distintos (4): 0x00, 0x26, 0x58, 0x5B - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x58 -> 33 veces - 0x26 -> 30 veces - 0x5B -> 20 veces - -Offset 0x050B5 (20661): - Valores distintos (4): 0x00, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x03 -> 33 veces - 0x05 -> 30 veces - 0x04 -> 20 veces - -Offset 0x050D0 (20688): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x05 -> 50 veces - 0x04 -> 33 veces - -Offset 0x050D1 (20689): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 201 veces - 0x01 -> 33 veces - -Offset 0x050D3 (20691): - Valores distintos (3): 0x00, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x0B -> 45 veces - 0x0A -> 5 veces - -Offset 0x050D4 (20692): - Valores distintos (4): 0x00, 0x58, 0x7C, 0xA6 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xA6 -> 45 veces - 0x58 -> 33 veces - 0x7C -> 5 veces - -Offset 0x050D5 (20693): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x04 -> 50 veces - 0x03 -> 33 veces - -Offset 0x050D8 (20696): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x05 -> 50 veces - 0x04 -> 33 veces - -Offset 0x050D9 (20697): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 50 veces - -Offset 0x050DB (20699): - Valores distintos (4): 0x00, 0x01, 0x07, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x0B -> 36 veces - 0x07 -> 9 veces - 0x01 -> 5 veces - -Offset 0x050DC (20700): - Valores distintos (5): 0x00, 0x7C, 0x85, 0xA6, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xE0 -> 36 veces - 0x85 -> 33 veces - 0xA6 -> 9 veces - 0x7C -> 5 veces - -Offset 0x050DD (20701): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x04 -> 50 veces - 0x03 -> 33 veces - -Offset 0x050E0 (20704): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x05 -> 50 veces - 0x04 -> 33 veces - -Offset 0x050E1 (20705): - Valores distintos (3): 0x00, 0x01, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x02 -> 50 veces - 0x01 -> 33 veces - -Offset 0x050E3 (20707): - Valores distintos (4): 0x00, 0x05, 0x0A, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x0B -> 36 veces - 0x0A -> 9 veces - 0x05 -> 5 veces - -Offset 0x050E4 (20708): - Valores distintos (5): 0x00, 0x7C, 0x85, 0xA6, 0xBF - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xBF -> 36 veces - 0x85 -> 33 veces - 0xA6 -> 9 veces - 0x7C -> 5 veces - -Offset 0x050E5 (20709): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x04 -> 50 veces - 0x03 -> 33 veces - -Offset 0x050E8 (20712): - Valores distintos (4): 0x00, 0x04, 0x0B, 0x0C - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x0C -> 30 veces - 0x04 -> 26 veces - 0x0B -> 20 veces - -Offset 0x050E9 (20713): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 208 veces - 0x01 -> 26 veces - -Offset 0x050EB (20715): - Valores distintos (4): 0x00, 0x05, 0x13, 0x26 - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0x13 -> 9 veces - 0x26 -> 6 veces - 0x05 -> 5 veces - -Offset 0x050EC (20716): - Valores distintos (6): 0x00, 0x26, 0x7C, 0xA6, 0xCE, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x26 -> 30 veces - 0xCE -> 26 veces - 0xA6 -> 9 veces - 0xE0 -> 6 veces - -Offset 0x050ED (20717): - Valores distintos (4): 0x00, 0x03, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x05 -> 30 veces - 0x03 -> 26 veces - 0x04 -> 20 veces - -Offset 0x050F0 (20720): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x05 -> 50 veces - 0x04 -> 26 veces - -Offset 0x050F1 (20721): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag - Más frecuentes: - 0x00 -> 208 veces - 0x01 -> 26 veces - -Offset 0x050F2 (20722): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 184 veces - 0x01 -> 50 veces - -Offset 0x050F3 (20723): - Valores distintos (4): 0x00, 0x05, 0x08, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 184 veces - 0x0B -> 36 veces - 0x08 -> 9 veces - 0x05 -> 5 veces - -Offset 0x050F4 (20724): - Valores distintos (5): 0x00, 0x7C, 0xA6, 0xCE, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0xE0 -> 36 veces - 0xCE -> 26 veces - 0xA6 -> 9 veces - 0x7C -> 5 veces - -Offset 0x050F5 (20725): - Valores distintos (3): 0x00, 0x03, 0x04 - Clasificación: small_state - Más frecuentes: - 0x00 -> 158 veces - 0x04 -> 50 veces - 0x03 -> 26 veces - -Offset 0x050F8 (20728): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x05 -> 36 veces - -Offset 0x050F9 (20729): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x050FA (20730): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x050FB (20731): - Valores distintos (3): 0x00, 0x01, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x0B -> 30 veces - 0x01 -> 6 veces - -Offset 0x050FC (20732): - Valores distintos (3): 0x00, 0xA1, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0xA1 -> 30 veces - 0xE0 -> 6 veces - -Offset 0x050FD (20733): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x05 -> 30 veces - 0x04 -> 6 veces - -Offset 0x05100 (20736): - Valores distintos (2): 0x00, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x05 -> 36 veces - -Offset 0x05101 (20737): - Valores distintos (2): 0x00, 0x02 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x02 -> 36 veces - -Offset 0x05102 (20738): - Valores distintos (2): 0x00, 0x01 - Clasificación: binary_flag_one_way - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 36 veces - -Offset 0x05103 (20739): - Valores distintos (3): 0x00, 0x01, 0x0B - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x0B -> 30 veces - 0x01 -> 6 veces - -Offset 0x05104 (20740): - Valores distintos (3): 0x00, 0x6C, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x6C -> 30 veces - 0xE0 -> 6 veces - -Offset 0x05105 (20741): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x05 -> 30 veces - 0x04 -> 6 veces - -Offset 0x05108 (20744): - Valores distintos (3): 0x00, 0x07, 0x0D - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x07 -> 30 veces - 0x0D -> 6 veces - -Offset 0x0510C (20748): - Valores distintos (3): 0x00, 0x26, 0xE0 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x26 -> 30 veces - 0xE0 -> 6 veces - -Offset 0x0510D (20749): - Valores distintos (3): 0x00, 0x04, 0x05 - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x05 -> 30 veces - 0x04 -> 6 veces - -Offset 0x05115 (20757): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x53 -> 97 veces - -Offset 0x05116 (20758): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x65 -> 97 veces - -Offset 0x05117 (20759): - Valores distintos (2): 0x00, 0x72 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x72 -> 97 veces - -Offset 0x05118 (20760): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6F -> 97 veces - -Offset 0x05119 (20761): - Valores distintos (2): 0x00, 0x77 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x77 -> 97 veces - -Offset 0x0513D (20797): - Valores distintos (2): 0x00, 0x50 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x50 -> 83 veces - -Offset 0x0513E (20798): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x6F -> 83 veces - -Offset 0x0513F (20799): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x6F -> 83 veces - -Offset 0x05140 (20800): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x63 -> 83 veces - -Offset 0x05141 (20801): - Valores distintos (2): 0x00, 0x68 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x68 -> 83 veces - -Offset 0x05147 (20807): - Valores distintos (2): 0x00, 0x43 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x43 -> 97 veces - -Offset 0x05148 (20808): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6F -> 97 veces - -Offset 0x05149 (20809): - Valores distintos (2): 0x00, 0x6F - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6F -> 97 veces - -Offset 0x0514A (20810): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFF -> 97 veces - -Offset 0x0514B (20811): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFF -> 97 veces - -Offset 0x0516F (20847): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x4B -> 97 veces - -Offset 0x05170 (20848): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x61 -> 97 veces - -Offset 0x05171 (20849): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6C -> 97 veces - -Offset 0x05172 (20850): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x65 -> 97 veces - -Offset 0x05173 (20851): - Valores distintos (2): 0x00, 0x6E - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6E -> 97 veces - -Offset 0x05183 (20867): - Valores distintos (2): 0x00, 0x50 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x50 -> 97 veces - -Offset 0x05184 (20868): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x69 -> 97 veces - -Offset 0x05185 (20869): - Valores distintos (2): 0x00, 0x6E - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6E -> 97 veces - -Offset 0x05186 (20870): - Valores distintos (2): 0x00, 0x6B - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6B -> 97 veces - -Offset 0x05187 (20871): - Valores distintos (2): 0x00, 0x79 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x79 -> 97 veces - -Offset 0x05188 (20872): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x53 -> 97 veces - -Offset 0x05189 (20873): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x69 -> 97 veces - -Offset 0x0518A (20874): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6C -> 97 veces - -Offset 0x0518B (20875): - Valores distintos (2): 0x00, 0x76 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x76 -> 97 veces - -Offset 0x0518C (20876): - Valores distintos (2): 0x00, 0x79 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x79 -> 97 veces - -Offset 0x0518D (20877): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x53 -> 83 veces - -Offset 0x0518E (20878): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x70 -> 83 veces - -Offset 0x0518F (20879): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x69 -> 83 veces - -Offset 0x05190 (20880): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x63 -> 83 veces - -Offset 0x05191 (20881): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x65 -> 83 veces - -Offset 0x05192 (20882): - Valores distintos (2): 0x00, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x4D -> 97 veces - -Offset 0x05193 (20883): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x61 -> 97 veces - -Offset 0x05194 (20884): - Valores distintos (2): 0x00, 0x72 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x72 -> 97 veces - -Offset 0x05195 (20885): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x69 -> 97 veces - -Offset 0x05196 (20886): - Valores distintos (2): 0x00, 0x6E - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6E -> 97 veces - -Offset 0x05197 (20887): - Valores distintos (2): 0x00, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x41 -> 97 veces - -Offset 0x05198 (20888): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6C -> 97 veces - -Offset 0x05199 (20889): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x70 -> 97 veces - -Offset 0x0519A (20890): - Valores distintos (2): 0x00, 0x68 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x68 -> 97 veces - -Offset 0x0519B (20891): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x61 -> 97 veces - -Offset 0x051BA (20922): - Valores distintos (2): 0x00, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x41 -> 97 veces - -Offset 0x051BB (20923): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x70 -> 97 veces - -Offset 0x051BC (20924): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x70 -> 97 veces - -Offset 0x051BD (20925): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6C -> 97 veces - -Offset 0x051BE (20926): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x65 -> 97 veces - -Offset 0x051BF (20927): - Valores distintos (2): 0x00, 0x54 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x54 -> 97 veces - -Offset 0x051C0 (20928): - Valores distintos (2): 0x00, 0x75 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x75 -> 97 veces - -Offset 0x051C1 (20929): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6C -> 97 veces - -Offset 0x051C2 (20930): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x69 -> 97 veces - -Offset 0x051C3 (20931): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x70 -> 97 veces - -Offset 0x051E7 (20967): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x53 -> 97 veces - -Offset 0x051E8 (20968): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x70 -> 97 veces - -Offset 0x051E9 (20969): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x69 -> 97 veces - -Offset 0x051EA (20970): - Valores distintos (2): 0x00, 0x74 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x74 -> 97 veces - -Offset 0x051EB (20971): - Valores distintos (2): 0x00, 0x7A - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x7A -> 97 veces - -Offset 0x05205 (20997): - Valores distintos (2): 0x00, 0x57 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x57 -> 97 veces - -Offset 0x05206 (20998): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x61 -> 97 veces - -Offset 0x05207 (20999): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6C -> 97 veces - -Offset 0x05208 (21000): - Valores distintos (2): 0x00, 0x64 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x64 -> 97 veces - -Offset 0x05209 (21001): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFF -> 97 veces - -Offset 0x0520A (21002): - Valores distintos (2): 0x00, 0x52 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x52 -> 97 veces - -Offset 0x0520B (21003): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x65 -> 97 veces - -Offset 0x0520C (21004): - Valores distintos (2): 0x00, 0x62 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x62 -> 97 veces - -Offset 0x0520D (21005): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x65 -> 97 veces - -Offset 0x0520E (21006): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFF -> 97 veces - -Offset 0x0520F (21007): - Valores distintos (2): 0x00, 0x59 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x59 -> 97 veces - -Offset 0x05210 (21008): - Valores distintos (2): 0x00, 0x69 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x69 -> 97 veces - -Offset 0x05211 (21009): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x70 -> 97 veces - -Offset 0x05212 (21010): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFF -> 97 veces - -Offset 0x05213 (21011): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFF -> 97 veces - -Offset 0x05214 (21012): - Valores distintos (2): 0x00, 0x53 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x53 -> 97 veces - -Offset 0x05215 (21013): - Valores distintos (2): 0x00, 0x63 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x63 -> 97 veces - -Offset 0x05216 (21014): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x61 -> 97 veces - -Offset 0x05217 (21015): - Valores distintos (2): 0x00, 0x74 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x74 -> 97 veces - -Offset 0x05218 (21016): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0xFF -> 97 veces - -Offset 0x05219 (21017): - Valores distintos (2): 0x00, 0x50 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x50 -> 83 veces - -Offset 0x0521A (21018): - Valores distintos (2): 0x00, 0x66 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x66 -> 83 veces - -Offset 0x0521B (21019): - Valores distintos (2): 0x00, 0x61 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x61 -> 83 veces - -Offset 0x0521C (21020): - Valores distintos (2): 0x00, 0x75 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x75 -> 83 veces - -Offset 0x0521D (21021): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xFF -> 83 veces - -Offset 0x0521E (21022): - Valores distintos (2): 0x00, 0x44 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x44 -> 83 veces - -Offset 0x0521F (21023): - Valores distintos (2): 0x00, 0x72 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x72 -> 83 veces - -Offset 0x05220 (21024): - Valores distintos (2): 0x00, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x3E -> 83 veces - -Offset 0x05221 (21025): - Valores distintos (2): 0x00, 0x4B - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x4B -> 83 veces - -Offset 0x05222 (21026): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xFF -> 83 veces - -Offset 0x05223 (21027): - Valores distintos (2): 0x00, 0x41 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x41 -> 97 veces - -Offset 0x05224 (21028): - Valores distintos (2): 0x00, 0x70 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x70 -> 97 veces - -Offset 0x05225 (21029): - Valores distintos (2): 0x00, 0x66 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x66 -> 97 veces - -Offset 0x05226 (21030): - Valores distintos (2): 0x00, 0x65 - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x65 -> 97 veces - -Offset 0x05227 (21031): - Valores distintos (2): 0x00, 0x6C - Clasificación: small_state - Más frecuentes: - 0x00 -> 137 veces - 0x6C -> 97 veces - -Offset 0x05228 (21032): - Valores distintos (2): 0x00, 0x4D - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x4D -> 83 veces - -Offset 0x05229 (21033): - Valores distintos (2): 0x00, 0x72 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x72 -> 83 veces - -Offset 0x0522A (21034): - Valores distintos (2): 0x00, 0x3E - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x3E -> 83 veces - -Offset 0x0522B (21035): - Valores distintos (2): 0x00, 0x51 - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x51 -> 83 veces - -Offset 0x0522C (21036): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0xFF -> 83 veces - -Offset 0x06000 (24576): - Valores distintos (2): 0x53, 0xFF - Clasificación: small_state - Más frecuentes: - 0x53 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06001 (24577): - Valores distintos (2): 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x43 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06002 (24578): - Valores distintos (2): 0x13, 0xFF - Clasificación: small_state - Más frecuentes: - 0x13 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06003 (24579): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06004 (24580): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06005 (24581): - Valores distintos (2): 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x61 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06006 (24582): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06007 (24583): - Valores distintos (2): 0x92, 0xFF - Clasificación: small_state - Más frecuentes: - 0x92 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06008 (24584): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06009 (24585): - Valores distintos (2): 0x85, 0xFF - Clasificación: small_state - Más frecuentes: - 0x85 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0600A (24586): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0600B (24587): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0600C (24588): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0600D (24589): - Valores distintos (2): 0x94, 0xFF - Clasificación: small_state - Más frecuentes: - 0x94 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0600E (24590): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0600F (24591): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06010 (24592): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06011 (24593): - Valores distintos (2): 0x40, 0xFF - Clasificación: small_state - Más frecuentes: - 0x40 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06012 (24594): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06013 (24595): - Valores distintos (2): 0x8F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x8F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06014 (24596): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06015 (24597): - Valores distintos (2): 0x86, 0xFF - Clasificación: small_state - Más frecuentes: - 0x86 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06016 (24598): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06017 (24599): - Valores distintos (2): 0x40, 0xFF - Clasificación: small_state - Más frecuentes: - 0x40 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06018 (24600): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06019 (24601): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0601A (24602): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0601B (24603): - Valores distintos (2): 0x89, 0xFF - Clasificación: small_state - Más frecuentes: - 0x89 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0601C (24604): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0601D (24605): - Valores distintos (2): 0x92, 0xFF - Clasificación: small_state - Más frecuentes: - 0x92 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0601E (24606): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0601F (24607): - Valores distintos (2): 0x85, 0xFF - Clasificación: small_state - Más frecuentes: - 0x85 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06020 (24608): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06021 (24609): - Valores distintos (2): 0x40, 0xFF - Clasificación: small_state - Más frecuentes: - 0x40 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06022 (24610): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06023 (24611): - Valores distintos (2): 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06024 (24612): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06025 (24613): - Valores distintos (2): 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x69 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06026 (24614): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06027 (24615): - Valores distintos (2): 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06028 (24616): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06029 (24617): - Valores distintos (2): 0x6A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6A -> 225 veces - 0xFF -> 9 veces - -Offset 0x0602A (24618): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0602B (24619): - Valores distintos (2): 0x40, 0xFF - Clasificación: small_state - Más frecuentes: - 0x40 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0602C (24620): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0602D (24621): - Valores distintos (6): 0x4F, 0x50, 0x51, 0x53, 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x51 -> 75 veces - 0x4F -> 52 veces - 0x50 -> 50 veces - 0x53 -> 27 veces - 0x55 -> 21 veces - -Offset 0x0602E (24622): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0602F (24623): - Valores distintos (9): 0x50, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x56 -> 100 veces - 0x57 -> 46 veces - 0x52 -> 20 veces - 0x54 -> 20 veces - 0x50 -> 13 veces - -Offset 0x06030 (24624): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06031 (24625): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06032 (24626): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06033 (24627): - Valores distintos (7): 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x53 -> 107 veces - 0x54 -> 34 veces - 0x51 -> 29 veces - 0x52 -> 22 veces - 0x4F -> 20 veces - -Offset 0x06034 (24628): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06035 (24629): - Valores distintos (8): 0x4F, 0x50, 0x51, 0x52, 0x54, 0x57, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 91 veces - 0x57 -> 67 veces - 0x54 -> 32 veces - 0x58 -> 19 veces - 0xFF -> 9 veces - -Offset 0x06036 (24630): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06037 (24631): - Valores distintos (2): 0x8D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x8D -> 225 veces - 0xFF -> 9 veces - -Offset 0x06038 (24632): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06039 (24633): - Valores distintos (2): 0x40, 0xFF - Clasificación: small_state - Más frecuentes: - 0x40 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0603A (24634): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0603B (24635): - Valores distintos (2): 0x6B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6B -> 225 veces - 0xFF -> 9 veces - -Offset 0x0603C (24636): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0603D (24637): - Valores distintos (2): 0x96, 0xFF - Clasificación: small_state - Más frecuentes: - 0x96 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0603E (24638): - Valores distintos (2): 0x81, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0603F (24639): - Valores distintos (2): 0x44, 0xFF - Clasificación: small_state - Más frecuentes: - 0x44 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06040 (24640): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06041 (24641): - Valores distintos (6): 0x4F, 0x50, 0x51, 0x52, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x51 -> 117 veces - 0x50 -> 50 veces - 0x52 -> 27 veces - 0x54 -> 21 veces - 0x4F -> 10 veces - -Offset 0x06042 (24642): - Valores distintos (2): 0x82, 0xFF - Clasificación: small_state - Más frecuentes: - 0x82 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06043 (24643): - Valores distintos (9): 0x4F, 0x50, 0x51, 0x54, 0x55, 0x56, 0x57, 0x58, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x56 -> 107 veces - 0x4F -> 37 veces - 0x50 -> 34 veces - 0x54 -> 22 veces - 0x51 -> 12 veces - -Offset 0x06044 (24644): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06045 (24645): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06046 (24646): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06047 (24647): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06048 (24648): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06049 (24649): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0604A (24650): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0604B (24651): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0604C (24652): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0604D (24653): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0604E (24654): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0604F (24655): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06050 (24656): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06051 (24657): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06052 (24658): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06053 (24659): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06054 (24660): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06055 (24661): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06056 (24662): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06057 (24663): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06058 (24664): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06059 (24665): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0605A (24666): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0605B (24667): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0605C (24668): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0605D (24669): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0605E (24670): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0605F (24671): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06060 (24672): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06061 (24673): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06062 (24674): - Valores distintos (2): 0xBE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBE -> 225 veces - 0xFF -> 9 veces - -Offset 0x06063 (24675): - Valores distintos (2): 0x5B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06064 (24676): - Valores distintos (2): 0xBC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBC -> 225 veces - 0xFF -> 9 veces - -Offset 0x06065 (24677): - Valores distintos (2): 0x42, 0xFF - Clasificación: small_state - Más frecuentes: - 0x42 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06066 (24678): - Valores distintos (2): 0xD7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xD7 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06067 (24679): - Valores distintos (2): 0x31, 0xFF - Clasificación: small_state - Más frecuentes: - 0x31 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06068 (24680): - Valores distintos (2): 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06069 (24681): - Valores distintos (2): 0x31, 0xFF - Clasificación: small_state - Más frecuentes: - 0x31 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0606A (24682): - Valores distintos (2): 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 225 veces - 0xFF -> 9 veces - -Offset 0x0606B (24683): - Valores distintos (2): 0x47, 0xFF - Clasificación: small_state - Más frecuentes: - 0x47 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0606C (24684): - Valores distintos (2): 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x27 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0606D (24685): - Valores distintos (2): 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5A -> 225 veces - 0xFF -> 9 veces - -Offset 0x0606E (24686): - Valores distintos (2): 0x85, 0xFF - Clasificación: small_state - Más frecuentes: - 0x85 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0606F (24687): - Valores distintos (2): 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06070 (24688): - Valores distintos (2): 0xE3, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE3 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06071 (24689): - Valores distintos (2): 0x4C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4C -> 225 veces - 0xFF -> 9 veces - -Offset 0x06072 (24690): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06073 (24691): - Valores distintos (2): 0x1C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1C -> 225 veces - 0xFF -> 9 veces - -Offset 0x06074 (24692): - Valores distintos (2): 0x7B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x7B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06075 (24693): - Valores distintos (2): 0x7B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x7B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06076 (24694): - Valores distintos (2): 0xF4, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF4 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06077 (24695): - Valores distintos (2): 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 225 veces - 0xFF -> 9 veces - -Offset 0x06078 (24696): - Valores distintos (2): 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06079 (24697): - Valores distintos (2): 0x18, 0xFF - Clasificación: small_state - Más frecuentes: - 0x18 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0607A (24698): - Valores distintos (2): 0x94, 0xFF - Clasificación: small_state - Más frecuentes: - 0x94 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0607B (24699): - Valores distintos (2): 0x5E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5E -> 225 veces - 0xFF -> 9 veces - -Offset 0x0607C (24700): - Valores distintos (2): 0xD2, 0xFF - Clasificación: small_state - Más frecuentes: - 0xD2 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0607D (24701): - Valores distintos (2): 0x59, 0xFF - Clasificación: small_state - Más frecuentes: - 0x59 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0607E (24702): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0607F (24703): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06080 (24704): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06081 (24705): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06082 (24706): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06083 (24707): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06084 (24708): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06085 (24709): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06086 (24710): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06087 (24711): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06088 (24712): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06089 (24713): - Valores distintos (2): 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0608A (24714): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0608B (24715): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0608C (24716): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0608D (24717): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0608E (24718): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0608F (24719): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06090 (24720): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06091 (24721): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06092 (24722): - Valores distintos (2): 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x76 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06093 (24723): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06094 (24724): - Valores distintos (2): 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06095 (24725): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06096 (24726): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06097 (24727): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06098 (24728): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06099 (24729): - Valores distintos (2): 0x79, 0xFF - Clasificación: small_state - Más frecuentes: - 0x79 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0609A (24730): - Valores distintos (2): 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0609B (24731): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0609C (24732): - Valores distintos (2): 0x56, 0xFF - Clasificación: small_state - Más frecuentes: - 0x56 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0609D (24733): - Valores distintos (2): 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x76 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0609E (24734): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0609F (24735): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A0 (24736): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A1 (24737): - Valores distintos (2): 0x67, 0xFF - Clasificación: small_state - Más frecuentes: - 0x67 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A2 (24738): - Valores distintos (2): 0x56, 0xFF - Clasificación: small_state - Más frecuentes: - 0x56 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A3 (24739): - Valores distintos (2): 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A4 (24740): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A5 (24741): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A6 (24742): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A7 (24743): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A8 (24744): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060A9 (24745): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060AA (24746): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060AB (24747): - Valores distintos (2): 0x56, 0xFF - Clasificación: small_state - Más frecuentes: - 0x56 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060AC (24748): - Valores distintos (2): 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060AD (24749): - Valores distintos (2): 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5A -> 225 veces - 0xFF -> 9 veces - -Offset 0x060AE (24750): - Valores distintos (2): 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x76 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060AF (24751): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B0 (24752): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B1 (24753): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B2 (24754): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B3 (24755): - Valores distintos (2): 0x57, 0xFF - Clasificación: small_state - Más frecuentes: - 0x57 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B4 (24756): - Valores distintos (2): 0xAA, 0xFF - Clasificación: small_state - Más frecuentes: - 0xAA -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B5 (24757): - Valores distintos (2): 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B6 (24758): - Valores distintos (2): 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x76 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B7 (24759): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B8 (24760): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060B9 (24761): - Valores distintos (2): 0x89, 0xFF - Clasificación: small_state - Más frecuentes: - 0x89 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060BA (24762): - Valores distintos (2): 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060BB (24763): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060BC (24764): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060BD (24765): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060BE (24766): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060BF (24767): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C0 (24768): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C1 (24769): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C2 (24770): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C3 (24771): - Valores distintos (2): 0x44, 0xFF - Clasificación: small_state - Más frecuentes: - 0x44 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C4 (24772): - Valores distintos (2): 0x84, 0xFF - Clasificación: small_state - Más frecuentes: - 0x84 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C5 (24773): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C6 (24774): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C7 (24775): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C8 (24776): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060C9 (24777): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060CA (24778): - Valores distintos (2): 0x49, 0xFF - Clasificación: small_state - Más frecuentes: - 0x49 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060CB (24779): - Valores distintos (2): 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x43 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060CC (24780): - Valores distintos (2): 0x89, 0xFF - Clasificación: small_state - Más frecuentes: - 0x89 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060CD (24781): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060CE (24782): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060CF (24783): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D0 (24784): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D1 (24785): - Valores distintos (2): 0x9E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9E -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D2 (24786): - Valores distintos (2): 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x39 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D3 (24787): - Valores distintos (2): 0x93, 0xFF - Clasificación: small_state - Más frecuentes: - 0x93 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D4 (24788): - Valores distintos (2): 0x9D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9D -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D5 (24789): - Valores distintos (2): 0x34, 0xFF - Clasificación: small_state - Más frecuentes: - 0x34 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D6 (24790): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D7 (24791): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D8 (24792): - Valores distintos (2): 0xE9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060D9 (24793): - Valores distintos (2): 0xF4, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF4 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060DA (24794): - Valores distintos (2): 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x24 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060DB (24795): - Valores distintos (2): 0x93, 0xFF - Clasificación: small_state - Más frecuentes: - 0x93 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060DC (24796): - Valores distintos (2): 0x9D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9D -> 225 veces - 0xFF -> 9 veces - -Offset 0x060DD (24797): - Valores distintos (2): 0x33, 0xFF - Clasificación: small_state - Más frecuentes: - 0x33 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060DE (24798): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060DF (24799): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E0 (24800): - Valores distintos (2): 0xD9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xD9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E1 (24801): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E2 (24802): - Valores distintos (2): 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3F -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E3 (24803): - Valores distintos (2): 0x22, 0xFF - Clasificación: small_state - Más frecuentes: - 0x22 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E4 (24804): - Valores distintos (2): 0x93, 0xFF - Clasificación: small_state - Más frecuentes: - 0x93 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E5 (24805): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E6 (24806): - Valores distintos (2): 0xC9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xC9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E7 (24807): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E8 (24808): - Valores distintos (2): 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDF -> 225 veces - 0xFF -> 9 veces - -Offset 0x060E9 (24809): - Valores distintos (2): 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xB9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060EA (24810): - Valores distintos (2): 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFB -> 225 veces - 0xFF -> 9 veces - -Offset 0x060ED (24813): - Valores distintos (2): 0xBC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBC -> 225 veces - 0xFF -> 9 veces - -Offset 0x060EE (24814): - Valores distintos (2): 0xCB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xCB -> 225 veces - 0xFF -> 9 veces - -Offset 0x060EF (24815): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F0 (24816): - Valores distintos (2): 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEF -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F1 (24817): - Valores distintos (2): 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xB9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F2 (24818): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F3 (24819): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F4 (24820): - Valores distintos (2): 0xBE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBE -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F5 (24821): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F6 (24822): - Valores distintos (2): 0xDC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDC -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F7 (24823): - Valores distintos (2): 0xDD, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDD -> 225 veces - 0xFF -> 9 veces - -Offset 0x060F9 (24825): - Valores distintos (2): 0xC9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xC9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x060FA (24826): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x060FB (24827): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x060FC (24828): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x060FD (24829): - Valores distintos (2): 0xEB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEB -> 225 veces - 0xFF -> 9 veces - -Offset 0x060FE (24830): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x060FF (24831): - Valores distintos (2): 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 225 veces - 0xFF -> 9 veces - -Offset 0x06100 (24832): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06101 (24833): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06102 (24834): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06103 (24835): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06104 (24836): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06105 (24837): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06106 (24838): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06107 (24839): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06108 (24840): - Valores distintos (2): 0x89, 0xFF - Clasificación: small_state - Más frecuentes: - 0x89 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06109 (24841): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0610A (24842): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0610B (24843): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0610C (24844): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0610D (24845): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0610E (24846): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0610F (24847): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06110 (24848): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06111 (24849): - Valores distintos (2): 0x68, 0xFF - Clasificación: small_state - Más frecuentes: - 0x68 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06112 (24850): - Valores distintos (2): 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x76 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06113 (24851): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06114 (24852): - Valores distintos (2): 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06115 (24853): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06116 (24854): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06117 (24855): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06118 (24856): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06119 (24857): - Valores distintos (2): 0x89, 0xFF - Clasificación: small_state - Más frecuentes: - 0x89 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0611A (24858): - Valores distintos (2): 0x56, 0xFF - Clasificación: small_state - Más frecuentes: - 0x56 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0611B (24859): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0611C (24860): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0611D (24861): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0611E (24862): - Valores distintos (2): 0x97, 0xFF - Clasificación: small_state - Más frecuentes: - 0x97 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0611F (24863): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06120 (24864): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06121 (24865): - Valores distintos (2): 0x67, 0xFF - Clasificación: small_state - Más frecuentes: - 0x67 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06122 (24866): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06123 (24867): - Valores distintos (2): 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06124 (24868): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06125 (24869): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06126 (24870): - Valores distintos (2): 0x86, 0xFF - Clasificación: small_state - Más frecuentes: - 0x86 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06127 (24871): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06128 (24872): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06129 (24873): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0612A (24874): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0612B (24875): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0612C (24876): - Valores distintos (2): 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0612D (24877): - Valores distintos (2): 0xA5, 0xFF - Clasificación: small_state - Más frecuentes: - 0xA5 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0612E (24878): - Valores distintos (2): 0x75, 0xFF - Clasificación: small_state - Más frecuentes: - 0x75 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0612F (24879): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06130 (24880): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06131 (24881): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06132 (24882): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06133 (24883): - Valores distintos (2): 0x57, 0xFF - Clasificación: small_state - Más frecuentes: - 0x57 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06134 (24884): - Valores distintos (2): 0xA5, 0xFF - Clasificación: small_state - Más frecuentes: - 0xA5 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06135 (24885): - Valores distintos (2): 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5A -> 225 veces - 0xFF -> 9 veces - -Offset 0x06136 (24886): - Valores distintos (2): 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x76 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06137 (24887): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06138 (24888): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06139 (24889): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0613A (24890): - Valores distintos (2): 0x89, 0xFF - Clasificación: small_state - Más frecuentes: - 0x89 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0613B (24891): - Valores distintos (2): 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x76 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0613C (24892): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0613D (24893): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0613E (24894): - Valores distintos (2): 0x68, 0xFF - Clasificación: small_state - Más frecuentes: - 0x68 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0613F (24895): - Valores distintos (2): 0x86, 0xFF - Clasificación: small_state - Más frecuentes: - 0x86 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06140 (24896): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06141 (24897): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06142 (24898): - Valores distintos (2): 0x49, 0xFF - Clasificación: small_state - Más frecuentes: - 0x49 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06143 (24899): - Valores distintos (2): 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x48 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06144 (24900): - Valores distintos (2): 0x44, 0xFF - Clasificación: small_state - Más frecuentes: - 0x44 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06145 (24901): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06146 (24902): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06147 (24903): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06148 (24904): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06149 (24905): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0614A (24906): - Valores distintos (2): 0x9E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9E -> 225 veces - 0xFF -> 9 veces - -Offset 0x0614B (24907): - Valores distintos (2): 0x33, 0xFF - Clasificación: small_state - Más frecuentes: - 0x33 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0614C (24908): - Valores distintos (2): 0x94, 0xFF - Clasificación: small_state - Más frecuentes: - 0x94 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0614D (24909): - Valores distintos (2): 0x89, 0xFF - Clasificación: small_state - Más frecuentes: - 0x89 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0614E (24910): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0614F (24911): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06150 (24912): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06151 (24913): - Valores distintos (2): 0x9E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9E -> 225 veces - 0xFF -> 9 veces - -Offset 0x06152 (24914): - Valores distintos (2): 0x9E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9E -> 225 veces - 0xFF -> 9 veces - -Offset 0x06153 (24915): - Valores distintos (2): 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x43 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06154 (24916): - Valores distintos (2): 0xE9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06155 (24917): - Valores distintos (2): 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x48 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06156 (24918): - Valores distintos (2): 0x83, 0xFF - Clasificación: small_state - Más frecuentes: - 0x83 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06157 (24919): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06158 (24920): - Valores distintos (2): 0xE9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06159 (24921): - Valores distintos (2): 0xF4, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF4 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0615A (24922): - Valores distintos (2): 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x39 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0615B (24923): - Valores distintos (2): 0x42, 0xFF - Clasificación: small_state - Más frecuentes: - 0x42 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0615C (24924): - Valores distintos (2): 0xD9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xD9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0615D (24925): - Valores distintos (2): 0x49, 0xFF - Clasificación: small_state - Más frecuentes: - 0x49 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0615E (24926): - Valores distintos (2): 0x94, 0xFF - Clasificación: small_state - Más frecuentes: - 0x94 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0615F (24927): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06160 (24928): - Valores distintos (2): 0xD9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xD9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06161 (24929): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06162 (24930): - Valores distintos (2): 0x4F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06163 (24931): - Valores distintos (2): 0x22, 0xFF - Clasificación: small_state - Más frecuentes: - 0x22 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06164 (24932): - Valores distintos (2): 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x43 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06165 (24933): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06166 (24934): - Valores distintos (2): 0xC9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xC9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06167 (24935): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06168 (24936): - Valores distintos (2): 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDF -> 225 veces - 0xFF -> 9 veces - -Offset 0x06169 (24937): - Valores distintos (2): 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xB9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0616A (24938): - Valores distintos (2): 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFB -> 225 veces - 0xFF -> 9 veces - -Offset 0x0616D (24941): - Valores distintos (2): 0xBC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBC -> 225 veces - 0xFF -> 9 veces - -Offset 0x0616E (24942): - Valores distintos (2): 0xCB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xCB -> 225 veces - 0xFF -> 9 veces - -Offset 0x0616F (24943): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x06170 (24944): - Valores distintos (2): 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEF -> 225 veces - 0xFF -> 9 veces - -Offset 0x06171 (24945): - Valores distintos (2): 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xB9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06172 (24946): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x06173 (24947): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x06174 (24948): - Valores distintos (2): 0xBE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBE -> 225 veces - 0xFF -> 9 veces - -Offset 0x06175 (24949): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x06176 (24950): - Valores distintos (2): 0xDC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDC -> 225 veces - 0xFF -> 9 veces - -Offset 0x06177 (24951): - Valores distintos (2): 0xDD, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDD -> 225 veces - 0xFF -> 9 veces - -Offset 0x06179 (24953): - Valores distintos (2): 0xC9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xC9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0617A (24954): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x0617B (24955): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x0617C (24956): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x0617D (24957): - Valores distintos (2): 0xEB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEB -> 225 veces - 0xFF -> 9 veces - -Offset 0x0617E (24958): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x0617F (24959): - Valores distintos (2): 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 225 veces - 0xFF -> 9 veces - -Offset 0x06180 (24960): - Valores distintos (2): 0x89, 0xFF - Clasificación: small_state - Más frecuentes: - 0x89 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06181 (24961): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06182 (24962): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06183 (24963): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06184 (24964): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06185 (24965): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06186 (24966): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06187 (24967): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06188 (24968): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06189 (24969): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0618A (24970): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0618B (24971): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0618C (24972): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0618D (24973): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0618E (24974): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0618F (24975): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06190 (24976): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06191 (24977): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06192 (24978): - Valores distintos (2): 0x67, 0xFF - Clasificación: small_state - Más frecuentes: - 0x67 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06193 (24979): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06194 (24980): - Valores distintos (2): 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06195 (24981): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06196 (24982): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06197 (24983): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06198 (24984): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06199 (24985): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0619A (24986): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0619B (24987): - Valores distintos (2): 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0619C (24988): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0619D (24989): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0619E (24990): - Valores distintos (2): 0x97, 0xFF - Clasificación: small_state - Más frecuentes: - 0x97 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0619F (24991): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A0 (24992): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A1 (24993): - Valores distintos (2): 0x67, 0xFF - Clasificación: small_state - Más frecuentes: - 0x67 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A2 (24994): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A3 (24995): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A4 (24996): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A5 (24997): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A6 (24998): - Valores distintos (2): 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x76 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A7 (24999): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A8 (25000): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061A9 (25001): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061AA (25002): - Valores distintos (2): 0x67, 0xFF - Clasificación: small_state - Más frecuentes: - 0x67 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061AB (25003): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061AC (25004): - Valores distintos (2): 0x56, 0xFF - Clasificación: small_state - Más frecuentes: - 0x56 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061AD (25005): - Valores distintos (2): 0xA5, 0xFF - Clasificación: small_state - Más frecuentes: - 0xA5 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061AE (25006): - Valores distintos (2): 0x6A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6A -> 225 veces - 0xFF -> 9 veces - -Offset 0x061AF (25007): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B0 (25008): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B1 (25009): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B2 (25010): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B3 (25011): - Valores distintos (2): 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B4 (25012): - Valores distintos (2): 0xA5, 0xFF - Clasificación: small_state - Más frecuentes: - 0xA5 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B5 (25013): - Valores distintos (2): 0xAA, 0xFF - Clasificación: small_state - Más frecuentes: - 0xAA -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B6 (25014): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B7 (25015): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B8 (25016): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061B9 (25017): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061BA (25018): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061BB (25019): - Valores distintos (2): 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x69 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061BC (25020): - Valores distintos (2): 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061BD (25021): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061BE (25022): - Valores distintos (2): 0x68, 0xFF - Clasificación: small_state - Más frecuentes: - 0x68 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061BF (25023): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C0 (25024): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C1 (25025): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C2 (25026): - Valores distintos (2): 0x4C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4C -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C3 (25027): - Valores distintos (2): 0x33, 0xFF - Clasificación: small_state - Más frecuentes: - 0x33 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C4 (25028): - Valores distintos (2): 0x84, 0xFF - Clasificación: small_state - Más frecuentes: - 0x84 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C5 (25029): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C6 (25030): - Valores distintos (2): 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C7 (25031): - Valores distintos (2): 0x87, 0xFF - Clasificación: small_state - Más frecuentes: - 0x87 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C8 (25032): - Valores distintos (2): 0x90, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061C9 (25033): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061CA (25034): - Valores distintos (2): 0xE4, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE4 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061CB (25035): - Valores distintos (2): 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x39 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061CC (25036): - Valores distintos (2): 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x43 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061CD (25037): - Valores distintos (2): 0x97, 0xFF - Clasificación: small_state - Más frecuentes: - 0x97 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061CE (25038): - Valores distintos (2): 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x88 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061CF (25039): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D0 (25040): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D1 (25041): - Valores distintos (2): 0x9E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9E -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D2 (25042): - Valores distintos (2): 0xE4, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE4 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D3 (25043): - Valores distintos (2): 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x39 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D4 (25044): - Valores distintos (2): 0x94, 0xFF - Clasificación: small_state - Más frecuentes: - 0x94 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D5 (25045): - Valores distintos (2): 0x9E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9E -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D6 (25046): - Valores distintos (2): 0x84, 0xFF - Clasificación: small_state - Más frecuentes: - 0x84 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D7 (25047): - Valores distintos (2): 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x98 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D8 (25048): - Valores distintos (2): 0xE9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061D9 (25049): - Valores distintos (2): 0xF4, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF4 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061DA (25050): - Valores distintos (2): 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x39 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061DB (25051): - Valores distintos (2): 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061DC (25052): - Valores distintos (2): 0x94, 0xFF - Clasificación: small_state - Más frecuentes: - 0x94 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061DD (25053): - Valores distintos (2): 0x9D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9D -> 225 veces - 0xFF -> 9 veces - -Offset 0x061DE (25054): - Valores distintos (2): 0x94, 0xFF - Clasificación: small_state - Más frecuentes: - 0x94 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061DF (25055): - Valores distintos (2): 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E0 (25056): - Valores distintos (2): 0xD9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xD9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E1 (25057): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E2 (25058): - Valores distintos (2): 0x4F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4F -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E3 (25059): - Valores distintos (2): 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E4 (25060): - Valores distintos (2): 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E5 (25061): - Valores distintos (2): 0x94, 0xFF - Clasificación: small_state - Más frecuentes: - 0x94 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E6 (25062): - Valores distintos (2): 0x9F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9F -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E7 (25063): - Valores distintos (2): 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E8 (25064): - Valores distintos (2): 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDF -> 225 veces - 0xFF -> 9 veces - -Offset 0x061E9 (25065): - Valores distintos (2): 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xB9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061EA (25066): - Valores distintos (2): 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFB -> 225 veces - 0xFF -> 9 veces - -Offset 0x061ED (25069): - Valores distintos (2): 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBF -> 225 veces - 0xFF -> 9 veces - -Offset 0x061EE (25070): - Valores distintos (2): 0xCB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xCB -> 225 veces - 0xFF -> 9 veces - -Offset 0x061EF (25071): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F0 (25072): - Valores distintos (2): 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEF -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F1 (25073): - Valores distintos (2): 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xB9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F2 (25074): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F3 (25075): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F4 (25076): - Valores distintos (2): 0xBE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBE -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F5 (25077): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F6 (25078): - Valores distintos (2): 0xDC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDC -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F7 (25079): - Valores distintos (2): 0xDD, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDD -> 225 veces - 0xFF -> 9 veces - -Offset 0x061F9 (25081): - Valores distintos (2): 0xC9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xC9 -> 225 veces - 0xFF -> 9 veces - -Offset 0x061FA (25082): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x061FB (25083): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x061FC (25084): - Valores distintos (2): 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBB -> 225 veces - 0xFF -> 9 veces - -Offset 0x061FD (25085): - Valores distintos (2): 0xEB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEB -> 225 veces - 0xFF -> 9 veces - -Offset 0x061FE (25086): - Valores distintos (2): 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 225 veces - 0xFF -> 9 veces - -Offset 0x061FF (25087): - Valores distintos (2): 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 225 veces - 0xFF -> 9 veces - -Offset 0x06200 (25088): - Valores distintos (9): 0x01, 0x02, 0x03, 0x05, 0x06, 0x09, 0x0E, 0x0F, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 75 veces - 0x03 -> 43 veces - 0x0E -> 36 veces - 0x05 -> 25 veces - 0x06 -> 25 veces - -Offset 0x06201 (25089): - Valores distintos (4): 0x00, 0x40, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 209 veces - 0x40 -> 13 veces - 0xFF -> 9 veces - 0x41 -> 3 veces - -Offset 0x06202 (25090): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06203 (25091): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06204 (25092): - Valores distintos (5): 0x00, 0x05, 0x0B, 0x1B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 201 veces - 0x05 -> 20 veces - 0xFF -> 9 veces - 0x1B -> 3 veces - 0x0B -> 1 veces - -Offset 0x06205 (25093): - Valores distintos (4): 0x00, 0x03, 0x19, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 221 veces - 0xFF -> 9 veces - 0x19 -> 3 veces - 0x03 -> 1 veces - -Offset 0x06206 (25094): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 200 veces - 0xFF -> 34 veces - -Offset 0x06207 (25095): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 200 veces - 0xFF -> 34 veces - -Offset 0x06208 (25096): - Valores distintos (17): 0x00, 0x0E, 0x10, 0x11, 0x1A, 0x1C, 0x20, 0x26, 0x2D, 0x36, 0x42, 0x66, 0x72, 0xA1, 0xD9, 0xFA, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x10 -> 71 veces - 0x0E -> 27 veces - 0x11 -> 25 veces - 0x2D -> 20 veces - 0x36 -> 20 veces - -Offset 0x06209 (25097): - Valores distintos (5): 0x00, 0x01, 0x02, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 196 veces - 0x02 -> 20 veces - 0xFF -> 9 veces - 0x01 -> 8 veces - 0x06 -> 1 veces - -Offset 0x0620A (25098): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0620B (25099): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0620C (25100): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0620D (25101): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0620E (25102): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0620F (25103): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06210 (25104): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06211 (25105): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06212 (25106): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06213 (25107): - Valores distintos (3): 0x00, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x0A -> 12 veces - 0xFF -> 9 veces - -Offset 0x06214 (25108): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x07 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06215 (25109): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0xFF -> 21 veces - -Offset 0x06216 (25110): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06217 (25111): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06218 (25112): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06219 (25113): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0621A (25114): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0621B (25115): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0621C (25116): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0621D (25117): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0621E (25118): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0621F (25119): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06220 (25120): - Valores distintos (6): 0x00, 0x03, 0x08, 0x5C, 0xC8, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 193 veces - 0x08 -> 20 veces - 0xFF -> 9 veces - 0x03 -> 8 veces - 0x5C -> 3 veces - -Offset 0x06221 (25121): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06222 (25122): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 222 veces - 0xFF -> 9 veces - 0x02 -> 3 veces - -Offset 0x06223 (25123): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06224 (25124): - Valores distintos (11): 0x05, 0x1B, 0x25, 0x32, 0x4F, 0x5A, 0x75, 0x8D, 0x8F, 0xBF, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x5A -> 124 veces - 0x32 -> 28 veces - 0xBF -> 27 veces - 0x4F -> 17 veces - 0x8F -> 12 veces - -Offset 0x06225 (25125): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06226 (25126): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06227 (25127): - Valores distintos (5): 0x01, 0x03, 0x05, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 166 veces - 0x01 -> 55 veces - 0xFF -> 9 veces - 0x05 -> 3 veces - 0x07 -> 1 veces - -Offset 0x06228 (25128): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06229 (25129): - Valores distintos (3): 0x00, 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 188 veces - 0x80 -> 37 veces - 0xFF -> 9 veces - -Offset 0x0622A (25130): - Valores distintos (11): 0x05, 0x0F, 0x2B, 0x3F, 0x49, 0x4A, 0x57, 0x58, 0x5F, 0x6B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x3F -> 124 veces - 0x2B -> 28 veces - 0x4A -> 27 veces - 0x05 -> 17 veces - 0x0F -> 12 veces - -Offset 0x0622B (25131): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0622C (25132): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0622D (25133): - Valores distintos (3): 0x00, 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 181 veces - 0x80 -> 44 veces - 0xFF -> 9 veces - -Offset 0x0622E (25134): - Valores distintos (11): 0x04, 0x05, 0x0A, 0x0C, 0x0D, 0x0E, 0x14, 0x21, 0x2F, 0x60, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x0D -> 131 veces - 0x60 -> 28 veces - 0x0E -> 20 veces - 0x14 -> 17 veces - 0x21 -> 12 veces - -Offset 0x0622F (25135): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06230 (25136): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x07 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06231 (25137): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 27 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06232 (25138): - Valores distintos (4): 0x00, 0x05, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x06 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06233 (25139): - Valores distintos (3): 0x00, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x06 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06234 (25140): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x07 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06235 (25141): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06236 (25142): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06237 (25143): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06238 (25144): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06239 (25145): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0623A (25146): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0623B (25147): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0623C (25148): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0623D (25149): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0623E (25150): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0623F (25151): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06240 (25152): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06241 (25153): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06242 (25154): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06243 (25155): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06244 (25156): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06245 (25157): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06246 (25158): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06247 (25159): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06248 (25160): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06249 (25161): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0624A (25162): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0624B (25163): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0624C (25164): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0624D (25165): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0624E (25166): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0624F (25167): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06250 (25168): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06251 (25169): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06252 (25170): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06253 (25171): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06254 (25172): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06255 (25173): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06256 (25174): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06257 (25175): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06258 (25176): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06259 (25177): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0625A (25178): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0625B (25179): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0625C (25180): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0625D (25181): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0625E (25182): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0625F (25183): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06260 (25184): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06261 (25185): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06262 (25186): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06263 (25187): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06264 (25188): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06265 (25189): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06266 (25190): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06267 (25191): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06268 (25192): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06269 (25193): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0626A (25194): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0626B (25195): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0626C (25196): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0626D (25197): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0626E (25198): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0626F (25199): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06270 (25200): - Valores distintos (17): 0x13, 0x1C, 0x25, 0x27, 0x56, 0x59, 0x62, 0x78, 0x79, 0x97, 0x9E, 0xA9, 0xAA, 0xC5, 0xD6, 0xE5, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x27 -> 71 veces - 0x78 -> 28 veces - 0x13 -> 25 veces - 0xE5 -> 20 veces - 0xD6 -> 20 veces - -Offset 0x06271 (25201): - Valores distintos (19): 0x77, 0x91, 0x9C, 0x9E, 0x9F, 0xA0, 0xA5, 0xA7, 0xA9, 0xAA, 0xAB, 0xAD, 0xB6, 0xB8, 0xCA, 0xF1, 0xF4, 0xF5, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xF4 -> 71 veces - 0x77 -> 27 veces - 0xCA -> 25 veces - 0xA7 -> 20 veces - 0xA9 -> 20 veces - -Offset 0x06272 (25202): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06273 (25203): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06274 (25204): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06275 (25205): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06276 (25206): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06277 (25207): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06278 (25208): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06279 (25209): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0627A (25210): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0627B (25211): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0627C (25212): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0627D (25213): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0627E (25214): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0627F (25215): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06280 (25216): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06281 (25217): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06282 (25218): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06283 (25219): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06284 (25220): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06285 (25221): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06286 (25222): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06287 (25223): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06288 (25224): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06289 (25225): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0628A (25226): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0628B (25227): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0628C (25228): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0628D (25229): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0628E (25230): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0628F (25231): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06290 (25232): - Valores distintos (2): 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06291 (25233): - Valores distintos (2): 0x79, 0xFF - Clasificación: small_state - Más frecuentes: - 0x79 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06292 (25234): - Valores distintos (2): 0x75, 0xFF - Clasificación: small_state - Más frecuentes: - 0x75 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06293 (25235): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06294 (25236): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06295 (25237): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06296 (25238): - Valores distintos (14): 0x06, 0x08, 0x09, 0x0A, 0x0F, 0x11, 0x14, 0x15, 0x1A, 0x1B, 0x25, 0x33, 0x34, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 72 veces - 0x25 -> 27 veces - 0x15 -> 25 veces - 0x0F -> 22 veces - 0x0A -> 20 veces - -Offset 0x06297 (25239): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06298 (25240): - Valores distintos (17): 0x02, 0x14, 0x19, 0x1F, 0x22, 0x3E, 0x46, 0x5F, 0x72, 0x96, 0xA3, 0xB0, 0xB9, 0xCC, 0xD1, 0xE8, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xB0 -> 72 veces - 0x5F -> 27 veces - 0xB9 -> 25 veces - 0xE8 -> 20 veces - 0x1F -> 20 veces - -Offset 0x06299 (25241): - Valores distintos (14): 0x00, 0x02, 0x03, 0x11, 0x12, 0x1D, 0x2C, 0x32, 0x35, 0x54, 0x6D, 0x79, 0xE6, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x79 -> 72 veces - 0xE6 -> 27 veces - 0x32 -> 25 veces - 0x03 -> 22 veces - 0x12 -> 21 veces - -Offset 0x0629A (25242): - Valores distintos (5): 0x00, 0x01, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x0A -> 12 veces - 0xFF -> 9 veces - 0x09 -> 9 veces - -Offset 0x0629B (25243): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0629C (25244): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0629D (25245): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0629E (25246): - Valores distintos (7): 0x03, 0x06, 0x07, 0x0A, 0x18, 0x45, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 75 veces - 0x18 -> 48 veces - 0x06 -> 45 veces - 0x07 -> 25 veces - 0x03 -> 24 veces - -Offset 0x0629F (25247): - Valores distintos (7): 0x32, 0x33, 0x36, 0x37, 0x3D, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x37 -> 75 veces - 0x36 -> 50 veces - 0x33 -> 47 veces - 0x3D -> 27 veces - 0x41 -> 21 veces - -Offset 0x062A0 (25248): - Valores distintos (6): 0x23, 0x26, 0x27, 0x2A, 0x31, 0xFF - Clasificación: small_state - Más frecuentes: - 0x27 -> 75 veces - 0x26 -> 72 veces - 0x23 -> 30 veces - 0x2A -> 27 veces - 0x31 -> 21 veces - -Offset 0x062A1 (25249): - Valores distintos (5): 0x02, 0x08, 0x10, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 75 veces - 0x08 -> 70 veces - 0x1F -> 48 veces - 0x02 -> 32 veces - 0xFF -> 9 veces - -Offset 0x062A2 (25250): - Valores distintos (7): 0x00, 0x05, 0x09, 0x0E, 0x12, 0x18, 0xFF - Clasificación: small_state - Más frecuentes: - 0x12 -> 117 veces - 0x05 -> 36 veces - 0x00 -> 30 veces - 0x09 -> 22 veces - 0x0E -> 12 veces - -Offset 0x062A3 (25251): - Valores distintos (5): 0x00, 0x0A, 0x10, 0x13, 0xFF - Clasificación: small_state - Más frecuentes: - 0x13 -> 161 veces - 0x00 -> 30 veces - 0x10 -> 22 veces - 0x0A -> 12 veces - 0xFF -> 9 veces - -Offset 0x062A4 (25252): - Valores distintos (16): 0x04, 0x25, 0x26, 0x2D, 0x2F, 0x32, 0x33, 0x47, 0x57, 0x67, 0x80, 0x86, 0xB0, 0xB7, 0xE9, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xB7 -> 72 veces - 0xE9 -> 27 veces - 0x86 -> 25 veces - 0x04 -> 21 veces - 0x33 -> 20 veces - -Offset 0x062A5 (25253): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x062A6 (25254): - Valores distintos (16): 0x03, 0x14, 0x19, 0x1D, 0x21, 0x2C, 0x2E, 0x2F, 0x35, 0x37, 0x43, 0x46, 0x70, 0xC1, 0xC4, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x46 -> 72 veces - 0x70 -> 27 veces - 0x37 -> 25 veces - 0x19 -> 20 veces - 0x2E -> 20 veces - -Offset 0x062A7 (25255): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062A8 (25256): - Valores distintos (3): 0x01, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 189 veces - 0x0B -> 36 veces - 0xFF -> 9 veces - -Offset 0x062A9 (25257): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062AA (25258): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062AB (25259): - Valores distintos (4): 0x00, 0x01, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 168 veces - 0x09 -> 48 veces - 0xFF -> 14 veces - 0x01 -> 4 veces - -Offset 0x062AC (25260): - Valores distintos (13): 0x04, 0x25, 0x2D, 0x32, 0x3A, 0x57, 0x67, 0x80, 0x86, 0xB0, 0xB7, 0xE9, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xB7 -> 72 veces - 0xE9 -> 27 veces - 0x86 -> 25 veces - 0x57 -> 22 veces - 0x04 -> 21 veces - -Offset 0x062AD (25261): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x062AE (25262): - Valores distintos (14): 0x14, 0x1D, 0x21, 0x24, 0x2E, 0x2F, 0x35, 0x37, 0x43, 0x46, 0x82, 0xC1, 0xC4, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x46 -> 72 veces - 0x82 -> 27 veces - 0x37 -> 25 veces - 0x2E -> 22 veces - 0x24 -> 20 veces - -Offset 0x062AF (25263): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062B0 (25264): - Valores distintos (15): 0x18, 0x1C, 0x20, 0x25, 0x3C, 0x4B, 0x53, 0x55, 0x68, 0x76, 0x7A, 0x7D, 0xA4, 0xAA, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xAA -> 72 veces - 0x53 -> 27 veces - 0x76 -> 25 veces - 0x25 -> 20 veces - 0x4B -> 20 veces - -Offset 0x062B1 (25265): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x062B2 (25266): - Valores distintos (14): 0x18, 0x1D, 0x1F, 0x23, 0x35, 0x41, 0x52, 0x5D, 0x61, 0x8D, 0x90, 0xE3, 0xFC, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x90 -> 72 veces - 0xE3 -> 27 veces - 0x61 -> 25 veces - 0xFC -> 21 veces - 0x23 -> 20 veces - -Offset 0x062B3 (25267): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062B4 (25268): - Valores distintos (12): 0x05, 0x06, 0x08, 0x0E, 0x0F, 0x11, 0x16, 0x19, 0x20, 0x41, 0x42, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x19 -> 72 veces - 0x0F -> 33 veces - 0x20 -> 27 veces - 0x08 -> 22 veces - 0x0E -> 22 veces - -Offset 0x062B5 (25269): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062B6 (25270): - Valores distintos (13): 0x13, 0x1B, 0x21, 0x22, 0x25, 0x27, 0x2A, 0x2E, 0x2F, 0x5D, 0x97, 0x9D, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x2F -> 72 veces - 0x5D -> 27 veces - 0x27 -> 25 veces - 0x2A -> 25 veces - 0x25 -> 22 veces - -Offset 0x062B7 (25271): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062B8 (25272): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062B9 (25273): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062BA (25274): - Valores distintos (3): 0x01, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 189 veces - 0x0B -> 36 veces - 0xFF -> 9 veces - -Offset 0x062BB (25275): - Valores distintos (3): 0x02, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 204 veces - 0x07 -> 21 veces - 0xFF -> 9 veces - -Offset 0x062BC (25276): - Valores distintos (3): 0x02, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 213 veces - 0x07 -> 12 veces - 0xFF -> 9 veces - -Offset 0x062BD (25277): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062BE (25278): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062BF (25279): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062C0 (25280): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062C1 (25281): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062C2 (25282): - Valores distintos (3): 0x02, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 203 veces - 0x05 -> 22 veces - 0xFF -> 9 veces - -Offset 0x062C3 (25283): - Valores distintos (3): 0x02, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 213 veces - 0x05 -> 12 veces - 0xFF -> 9 veces - -Offset 0x062C4 (25284): - Valores distintos (5): 0x32, 0x37, 0x46, 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4B -> 75 veces - 0x32 -> 56 veces - 0x37 -> 52 veces - 0x46 -> 42 veces - 0xFF -> 9 veces - -Offset 0x062C5 (25285): - Valores distintos (2): 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 225 veces - 0xFF -> 9 veces - -Offset 0x062C6 (25286): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062C7 (25287): - Valores distintos (4): 0x04, 0x06, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 123 veces - 0x06 -> 98 veces - 0xFF -> 9 veces - 0x04 -> 4 veces - -Offset 0x062C8 (25288): - Valores distintos (3): 0x5F, 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 173 veces - 0x5F -> 52 veces - 0xFF -> 9 veces - -Offset 0x062C9 (25289): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062CA (25290): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062CB (25291): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062CC (25292): - Valores distintos (13): 0x04, 0x25, 0x2D, 0x32, 0x3A, 0x57, 0x67, 0x80, 0x86, 0xB0, 0xB7, 0xE9, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xB7 -> 72 veces - 0xE9 -> 27 veces - 0x86 -> 25 veces - 0x57 -> 22 veces - 0x04 -> 21 veces - -Offset 0x062CD (25293): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x062CE (25294): - Valores distintos (14): 0x14, 0x1D, 0x21, 0x24, 0x2E, 0x2F, 0x35, 0x37, 0x43, 0x46, 0x82, 0xC1, 0xC4, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x46 -> 72 veces - 0x82 -> 27 veces - 0x37 -> 25 veces - 0x2E -> 22 veces - 0x24 -> 20 veces - -Offset 0x062CF (25295): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062D0 (25296): - Valores distintos (14): 0x12, 0x16, 0x18, 0x1D, 0x34, 0x3E, 0x51, 0x56, 0x74, 0x7A, 0xB5, 0xDC, 0xDF, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x7A -> 72 veces - 0xB5 -> 27 veces - 0x56 -> 25 veces - 0x34 -> 22 veces - 0x1D -> 20 veces - -Offset 0x062D1 (25297): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062D2 (25298): - Valores distintos (13): 0x10, 0x13, 0x15, 0x19, 0x28, 0x30, 0x3B, 0x3F, 0x50, 0x53, 0x60, 0x64, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x53 -> 72 veces - 0x60 -> 27 veces - 0x3F -> 25 veces - 0x28 -> 22 veces - 0x64 -> 21 veces - -Offset 0x062D3 (25299): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062D4 (25300): - Valores distintos (12): 0x0B, 0x0D, 0x10, 0x16, 0x18, 0x1A, 0x21, 0x24, 0x34, 0x56, 0x57, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x24 -> 72 veces - 0x1A -> 42 veces - 0x34 -> 27 veces - 0x10 -> 22 veces - 0x16 -> 22 veces - -Offset 0x062D5 (25301): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062D6 (25302): - Valores distintos (13): 0x13, 0x1B, 0x21, 0x22, 0x25, 0x27, 0x2A, 0x2E, 0x2F, 0x5D, 0x97, 0x9D, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x2F -> 72 veces - 0x5D -> 27 veces - 0x27 -> 25 veces - 0x2A -> 25 veces - 0x25 -> 22 veces - -Offset 0x062D7 (25303): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062D8 (25304): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062D9 (25305): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062DA (25306): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062DB (25307): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062DC (25308): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062DD (25309): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062DE (25310): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062DF (25311): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062E0 (25312): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062E1 (25313): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062E2 (25314): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062E3 (25315): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062E4 (25316): - Valores distintos (3): 0x32, 0x37, 0xFF - Clasificación: small_state - Más frecuentes: - 0x37 -> 123 veces - 0x32 -> 102 veces - 0xFF -> 9 veces - -Offset 0x062E5 (25317): - Valores distintos (2): 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 225 veces - 0xFF -> 9 veces - -Offset 0x062E6 (25318): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062E7 (25319): - Valores distintos (3): 0x06, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 123 veces - 0x06 -> 102 veces - 0xFF -> 9 veces - -Offset 0x062E8 (25320): - Valores distintos (3): 0x5F, 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 123 veces - 0x5F -> 102 veces - 0xFF -> 9 veces - -Offset 0x062E9 (25321): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062EA (25322): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062EB (25323): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062EC (25324): - Valores distintos (2): 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x46 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062ED (25325): - Valores distintos (2): 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4B -> 225 veces - 0xFF -> 9 veces - -Offset 0x062EE (25326): - Valores distintos (3): 0x00, 0x47, 0xFF - Clasificación: small_state - Más frecuentes: - 0x47 -> 215 veces - 0x00 -> 10 veces - 0xFF -> 9 veces - -Offset 0x062EF (25327): - Valores distintos (3): 0x00, 0x4C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4C -> 165 veces - 0x00 -> 60 veces - 0xFF -> 9 veces - -Offset 0x062F0 (25328): - Valores distintos (3): 0x00, 0x73, 0xFF - Clasificación: small_state - Más frecuentes: - 0x73 -> 165 veces - 0x00 -> 60 veces - 0xFF -> 9 veces - -Offset 0x062F1 (25329): - Valores distintos (3): 0x00, 0x49, 0xFF - Clasificación: small_state - Más frecuentes: - 0x49 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x062F2 (25330): - Valores distintos (3): 0x00, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x48 -> 48 veces - 0xFF -> 9 veces - -Offset 0x062F3 (25331): - Valores distintos (3): 0x00, 0x4D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4D -> 48 veces - 0xFF -> 9 veces - -Offset 0x062F4 (25332): - Valores distintos (3): 0x00, 0x4A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4A -> 48 veces - 0xFF -> 9 veces - -Offset 0x062F5 (25333): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062F6 (25334): - Valores distintos (2): 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062F7 (25335): - Valores distintos (3): 0x00, 0x53, 0xFF - Clasificación: small_state - Más frecuentes: - 0x53 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x062F8 (25336): - Valores distintos (3): 0x00, 0x56, 0xFF - Clasificación: small_state - Más frecuentes: - 0x56 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x062F9 (25337): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062FA (25338): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062FB (25339): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062FC (25340): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062FD (25341): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062FE (25342): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x062FF (25343): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06300 (25344): - Valores distintos (3): 0x00, 0x97, 0xFF - Clasificación: small_state - Más frecuentes: - 0x97 -> 195 veces - 0x00 -> 30 veces - 0xFF -> 9 veces - -Offset 0x06301 (25345): - Valores distintos (3): 0x00, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x15 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06302 (25346): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06303 (25347): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06304 (25348): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06305 (25349): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06306 (25350): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06307 (25351): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06308 (25352): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06309 (25353): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0630A (25354): - Valores distintos (3): 0x00, 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 195 veces - 0x00 -> 30 veces - 0xFF -> 9 veces - -Offset 0x0630B (25355): - Valores distintos (3): 0x00, 0xAA, 0xFF - Clasificación: small_state - Más frecuentes: - 0xAA -> 174 veces - 0x00 -> 51 veces - 0xFF -> 9 veces - -Offset 0x0630C (25356): - Valores distintos (3): 0x00, 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x27 -> 195 veces - 0x00 -> 30 veces - 0xFF -> 9 veces - -Offset 0x0630D (25357): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x0630E (25358): - Valores distintos (3): 0x00, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x14 -> 127 veces - 0x00 -> 98 veces - 0xFF -> 9 veces - -Offset 0x0630F (25359): - Valores distintos (4): 0x00, 0x45, 0xC3, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x45 -> 75 veces - 0xC3 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06310 (25360): - Valores distintos (3): 0x00, 0xC6, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xC6 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06311 (25361): - Valores distintos (3): 0x00, 0xC9, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xC9 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06312 (25362): - Valores distintos (3): 0x00, 0xCE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xCE -> 21 veces - 0xFF -> 9 veces - -Offset 0x06313 (25363): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06314 (25364): - Valores distintos (6): 0x00, 0x07, 0x09, 0x1E, 0x33, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 168 veces - 0x1E -> 27 veces - 0x33 -> 21 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x06315 (25365): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 168 veces - 0xFD -> 48 veces - 0xFF -> 9 veces - 0x00 -> 9 veces - -Offset 0x06316 (25366): - Valores distintos (5): 0x00, 0x01, 0x03, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 168 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0x01 -> 4 veces - -Offset 0x06317 (25367): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 168 veces - 0x01 -> 48 veces - 0xFF -> 13 veces - 0x00 -> 5 veces - -Offset 0x06318 (25368): - Valores distintos (4): 0x00, 0x01, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 168 veces - 0xFD -> 48 veces - 0xFF -> 13 veces - 0x00 -> 5 veces - -Offset 0x06319 (25369): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0631A (25370): - Valores distintos (5): 0x00, 0x02, 0x03, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFD -> 168 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0x02 -> 4 veces - -Offset 0x0631B (25371): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0631C (25372): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0631D (25373): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0631E (25374): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0631F (25375): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06320 (25376): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06321 (25377): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06322 (25378): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06323 (25379): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06324 (25380): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06325 (25381): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06326 (25382): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06327 (25383): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06328 (25384): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06329 (25385): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0632A (25386): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0632B (25387): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0632C (25388): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0632D (25389): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0632E (25390): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0632F (25391): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06330 (25392): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06331 (25393): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06332 (25394): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06333 (25395): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06334 (25396): - Valores distintos (2): 0x4E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4E -> 225 veces - 0xFF -> 9 veces - -Offset 0x06335 (25397): - Valores distintos (2): 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x69 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06336 (25398): - Valores distintos (2): 0x6E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6E -> 225 veces - 0xFF -> 9 veces - -Offset 0x06337 (25399): - Valores distintos (2): 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x61 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06338 (25400): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06339 (25401): - Valores distintos (3): 0x01, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 123 veces - 0x01 -> 102 veces - 0xFF -> 9 veces - -Offset 0x0633A (25402): - Valores distintos (9): 0x05, 0x08, 0x0D, 0x0E, 0x0F, 0x10, 0x1A, 0x28, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x10 -> 75 veces - 0x05 -> 30 veces - 0x1A -> 27 veces - 0x0F -> 25 veces - 0x08 -> 22 veces - -Offset 0x0633B (25403): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 195 veces - 0x00 -> 30 veces - 0xFF -> 9 veces - -Offset 0x0633C (25404): - Valores distintos (10): 0x0F, 0x5A, 0x92, 0x93, 0x95, 0xBD, 0xD6, 0xE1, 0xF7, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xBD -> 75 veces - 0x5A -> 38 veces - 0x0F -> 27 veces - 0xF7 -> 25 veces - 0x92 -> 21 veces - -Offset 0x0633D (25405): - Valores distintos (9): 0x00, 0x01, 0x09, 0x0C, 0x10, 0x13, 0x6F, 0x98, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x13 -> 75 veces - 0x00 -> 30 veces - 0x6F -> 27 veces - 0x10 -> 25 veces - 0x01 -> 22 veces - -Offset 0x0633E (25406): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0633F (25407): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06340 (25408): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06341 (25409): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06342 (25410): - Valores distintos (6): 0x1E, 0x20, 0x21, 0x26, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 100 veces - 0x20 -> 45 veces - 0x1E -> 32 veces - 0x26 -> 27 veces - 0x28 -> 21 veces - -Offset 0x06343 (25411): - Valores distintos (6): 0x00, 0x32, 0x36, 0x38, 0x3C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x36 -> 100 veces - 0x32 -> 47 veces - 0x00 -> 30 veces - 0x38 -> 27 veces - 0x3C -> 21 veces - -Offset 0x06344 (25412): - Valores distintos (7): 0x00, 0x21, 0x26, 0x28, 0x29, 0x2C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x29 -> 75 veces - 0x26 -> 70 veces - 0x00 -> 30 veces - 0x28 -> 27 veces - 0x2C -> 21 veces - -Offset 0x06345 (25413): - Valores distintos (6): 0x05, 0x06, 0x0B, 0x12, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0B -> 75 veces - 0x05 -> 52 veces - 0x06 -> 50 veces - 0x12 -> 27 veces - 0x16 -> 21 veces - -Offset 0x06346 (25414): - Valores distintos (4): 0x00, 0x10, 0x18, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 125 veces - 0x18 -> 52 veces - 0x00 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06347 (25415): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 147 veces - 0x00 -> 78 veces - 0xFF -> 9 veces - -Offset 0x06348 (25416): - Valores distintos (11): 0x15, 0x19, 0x1B, 0x26, 0x3A, 0x3B, 0x3F, 0x42, 0x56, 0xC0, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x42 -> 75 veces - 0x1B -> 30 veces - 0x56 -> 27 veces - 0x3F -> 25 veces - 0xC0 -> 21 veces - -Offset 0x06349 (25417): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0634A (25418): - Valores distintos (9): 0x1E, 0x21, 0x2E, 0x45, 0x4D, 0x52, 0x57, 0xA2, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x57 -> 75 veces - 0x21 -> 31 veces - 0xA2 -> 27 veces - 0x52 -> 25 veces - 0x2E -> 21 veces - -Offset 0x0634B (25419): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0634C (25420): - Valores distintos (3): 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 224 veces - 0xFF -> 9 veces - 0x01 -> 1 veces - -Offset 0x0634D (25421): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0634E (25422): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0634F (25423): - Valores distintos (5): 0x05, 0x06, 0x07, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 75 veces - 0x05 -> 71 veces - 0xFF -> 40 veces - 0x08 -> 27 veces - 0x06 -> 21 veces - -Offset 0x06350 (25424): - Valores distintos (9): 0x1B, 0x26, 0x3A, 0x3B, 0x3F, 0x42, 0x62, 0xC0, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x42 -> 75 veces - 0x1B -> 30 veces - 0x62 -> 27 veces - 0x3F -> 25 veces - 0x26 -> 22 veces - -Offset 0x06351 (25425): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06352 (25426): - Valores distintos (9): 0x1E, 0x21, 0x2E, 0x45, 0x4D, 0x52, 0x57, 0xA2, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x57 -> 75 veces - 0x21 -> 30 veces - 0xA2 -> 27 veces - 0x52 -> 25 veces - 0x2E -> 22 veces - -Offset 0x06353 (25427): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06354 (25428): - Valores distintos (9): 0x13, 0x18, 0x26, 0x33, 0x3D, 0x3F, 0x6B, 0x87, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x3F -> 75 veces - 0x13 -> 30 veces - 0x6B -> 27 veces - 0x33 -> 25 veces - 0x3D -> 25 veces - -Offset 0x06355 (25429): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06356 (25430): - Valores distintos (10): 0x13, 0x1D, 0x22, 0x2C, 0x2F, 0x3B, 0x50, 0x7C, 0x96, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x50 -> 75 veces - 0x13 -> 30 veces - 0x7C -> 27 veces - 0x3B -> 25 veces - 0x96 -> 21 veces - -Offset 0x06357 (25431): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06358 (25432): - Valores distintos (9): 0x09, 0x0A, 0x0C, 0x10, 0x11, 0x14, 0x17, 0x27, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x14 -> 75 veces - 0x09 -> 30 veces - 0x17 -> 27 veces - 0x11 -> 25 veces - 0x10 -> 25 veces - -Offset 0x06359 (25433): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0635A (25434): - Valores distintos (10): 0x18, 0x23, 0x26, 0x32, 0x36, 0x38, 0x3D, 0x6F, 0xBF, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x3D -> 75 veces - 0x18 -> 30 veces - 0x6F -> 27 veces - 0x36 -> 25 veces - 0xBF -> 21 veces - -Offset 0x0635B (25435): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0635C (25436): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 27 veces - 0xFF -> 9 veces - -Offset 0x0635D (25437): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0635E (25438): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0635F (25439): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06360 (25440): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06361 (25441): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06362 (25442): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06363 (25443): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06364 (25444): - Valores distintos (3): 0x05, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 150 veces - 0x06 -> 75 veces - 0xFF -> 9 veces - -Offset 0x06365 (25445): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06366 (25446): - Valores distintos (4): 0x02, 0x03, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 125 veces - 0x02 -> 79 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06367 (25447): - Valores distintos (4): 0x02, 0x03, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 129 veces - 0x04 -> 75 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06368 (25448): - Valores distintos (2): 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06369 (25449): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0636A (25450): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0636B (25451): - Valores distintos (3): 0x0A, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 123 veces - 0x0A -> 102 veces - 0xFF -> 9 veces - -Offset 0x0636C (25452): - Valores distintos (2): 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0636D (25453): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0636E (25454): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0636F (25455): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06370 (25456): - Valores distintos (9): 0x1B, 0x26, 0x3A, 0x3B, 0x3F, 0x42, 0x62, 0xC0, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x42 -> 75 veces - 0x1B -> 30 veces - 0x62 -> 27 veces - 0x3F -> 25 veces - 0x26 -> 22 veces - -Offset 0x06371 (25457): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06372 (25458): - Valores distintos (9): 0x1E, 0x21, 0x2E, 0x45, 0x4D, 0x52, 0x57, 0xA2, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x57 -> 75 veces - 0x21 -> 30 veces - 0xA2 -> 27 veces - 0x52 -> 25 veces - 0x2E -> 22 veces - -Offset 0x06373 (25459): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06374 (25460): - Valores distintos (8): 0x0D, 0x12, 0x1F, 0x21, 0x23, 0x26, 0x2D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 75 veces - 0x0D -> 30 veces - 0x26 -> 27 veces - 0x1F -> 25 veces - 0x21 -> 25 veces - -Offset 0x06375 (25461): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06376 (25462): - Valores distintos (9): 0x0D, 0x10, 0x17, 0x1A, 0x1B, 0x1E, 0x2B, 0x34, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1E -> 75 veces - 0x0D -> 30 veces - 0x2B -> 27 veces - 0x1B -> 25 veces - 0x10 -> 22 veces - -Offset 0x06377 (25463): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06378 (25464): - Valores distintos (8): 0x0E, 0x11, 0x17, 0x1A, 0x1C, 0x26, 0x31, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1C -> 75 veces - 0x0E -> 30 veces - 0x26 -> 27 veces - 0x17 -> 25 veces - 0x1A -> 25 veces - -Offset 0x06379 (25465): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0637A (25466): - Valores distintos (9): 0x18, 0x23, 0x2F, 0x35, 0x36, 0x3D, 0x6F, 0xB0, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x3D -> 75 veces - 0x18 -> 30 veces - 0x6F -> 27 veces - 0x36 -> 25 veces - 0x23 -> 22 veces - -Offset 0x0637B (25467): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0637C (25468): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0637D (25469): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0637E (25470): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0637F (25471): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06380 (25472): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06381 (25473): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06382 (25474): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06383 (25475): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06384 (25476): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06385 (25477): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06386 (25478): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06387 (25479): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06388 (25480): - Valores distintos (2): 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06389 (25481): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0638A (25482): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0638B (25483): - Valores distintos (3): 0x0A, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 123 veces - 0x0A -> 102 veces - 0xFF -> 9 veces - -Offset 0x0638C (25484): - Valores distintos (2): 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0638D (25485): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0638E (25486): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0638F (25487): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06390 (25488): - Valores distintos (3): 0x00, 0x4F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4F -> 48 veces - 0xFF -> 9 veces - -Offset 0x06391 (25489): - Valores distintos (3): 0x00, 0x4E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4E -> 48 veces - 0xFF -> 9 veces - -Offset 0x06392 (25490): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06393 (25491): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06394 (25492): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06395 (25493): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06396 (25494): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06397 (25495): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06398 (25496): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06399 (25497): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0639A (25498): - Valores distintos (3): 0x00, 0x59, 0xFF - Clasificación: small_state - Más frecuentes: - 0x59 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x0639B (25499): - Valores distintos (3): 0x00, 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5A -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x0639C (25500): - Valores distintos (3): 0x00, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x58 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x0639D (25501): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0639E (25502): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0639F (25503): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063A0 (25504): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063A1 (25505): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063A2 (25506): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063A3 (25507): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063A4 (25508): - Valores distintos (2): 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063A5 (25509): - Valores distintos (2): 0x5E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5E -> 225 veces - 0xFF -> 9 veces - -Offset 0x063A6 (25510): - Valores distintos (2): 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x61 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063A7 (25511): - Valores distintos (3): 0x00, 0x67, 0xFF - Clasificación: small_state - Más frecuentes: - 0x67 -> 195 veces - 0x00 -> 30 veces - 0xFF -> 9 veces - -Offset 0x063A8 (25512): - Valores distintos (3): 0x00, 0x5F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5F -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x063A9 (25513): - Valores distintos (3): 0x00, 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x063AA (25514): - Valores distintos (3): 0x00, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x62 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x063AB (25515): - Valores distintos (3): 0x00, 0x60, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x60 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063AC (25516): - Valores distintos (3): 0x00, 0x68, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x68 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063AD (25517): - Valores distintos (3): 0x00, 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x63 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063AE (25518): - Valores distintos (4): 0x00, 0x0A, 0x29, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 127 veces - 0x00 -> 77 veces - 0x29 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063AF (25519): - Valores distintos (4): 0x00, 0x3F, 0xA4, 0xFF - Clasificación: small_state - Más frecuentes: - 0xA4 -> 127 veces - 0x00 -> 77 veces - 0x3F -> 21 veces - 0xFF -> 9 veces - -Offset 0x063B0 (25520): - Valores distintos (3): 0x00, 0xA5, 0xFF - Clasificación: small_state - Más frecuentes: - 0xA5 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x063B1 (25521): - Valores distintos (3): 0x00, 0xB3, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xB3 -> 48 veces - 0xFF -> 9 veces - -Offset 0x063B2 (25522): - Valores distintos (3): 0x00, 0xCF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xCF -> 48 veces - 0xFF -> 9 veces - -Offset 0x063B3 (25523): - Valores distintos (3): 0x00, 0xA9, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xA9 -> 48 veces - 0xFF -> 9 veces - -Offset 0x063B4 (25524): - Valores distintos (3): 0x00, 0xBC, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xBC -> 48 veces - 0xFF -> 9 veces - -Offset 0x063B5 (25525): - Valores distintos (3): 0x00, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063B6 (25526): - Valores distintos (3): 0x00, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x28 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063B7 (25527): - Valores distintos (3): 0x00, 0x8C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x8C -> 21 veces - 0xFF -> 9 veces - -Offset 0x063B8 (25528): - Valores distintos (6): 0x00, 0x08, 0x10, 0x18, 0x1E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 75 veces - 0x08 -> 71 veces - 0x00 -> 31 veces - 0x18 -> 27 veces - 0x1E -> 21 veces - -Offset 0x063B9 (25529): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063BA (25530): - Valores distintos (5): 0x00, 0x01, 0x03, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0x04 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063BB (25531): - Valores distintos (3): 0x00, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0xFE -> 102 veces - 0xFF -> 30 veces - -Offset 0x063BC (25532): - Valores distintos (3): 0x00, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 30 veces - 0xFE -> 27 veces - -Offset 0x063BD (25533): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xFF -> 30 veces - -Offset 0x063BE (25534): - Valores distintos (4): 0x00, 0x01, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0xFF -> 30 veces - 0x04 -> 27 veces - -Offset 0x063BF (25535): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C0 (25536): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C1 (25537): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C2 (25538): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C3 (25539): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C4 (25540): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C5 (25541): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C6 (25542): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C7 (25543): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C8 (25544): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063C9 (25545): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063CA (25546): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063CB (25547): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063CC (25548): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063CD (25549): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063CE (25550): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063CF (25551): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D0 (25552): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D1 (25553): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D2 (25554): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D3 (25555): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D4 (25556): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D5 (25557): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D6 (25558): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D7 (25559): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D8 (25560): - Valores distintos (2): 0x47, 0xFF - Clasificación: small_state - Más frecuentes: - 0x47 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063D9 (25561): - Valores distintos (2): 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x61 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063DA (25562): - Valores distintos (2): 0x72, 0xFF - Clasificación: small_state - Más frecuentes: - 0x72 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063DB (25563): - Valores distintos (2): 0x72, 0xFF - Clasificación: small_state - Más frecuentes: - 0x72 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063DC (25564): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063DD (25565): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063DE (25566): - Valores distintos (6): 0x0D, 0x0E, 0x15, 0x18, 0x2C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0D -> 77 veces - 0x15 -> 75 veces - 0x18 -> 27 veces - 0x0E -> 25 veces - 0x2C -> 21 veces - -Offset 0x063DF (25567): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x063E0 (25568): - Valores distintos (6): 0x8B, 0xB8, 0xD9, 0xE1, 0xE9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xB8 -> 77 veces - 0xD9 -> 75 veces - 0xE9 -> 27 veces - 0x8B -> 25 veces - 0xE1 -> 21 veces - -Offset 0x063E1 (25569): - Valores distintos (6): 0x0B, 0x11, 0x42, 0x62, 0xC1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0B -> 77 veces - 0x42 -> 75 veces - 0x62 -> 27 veces - 0x11 -> 25 veces - 0xC1 -> 21 veces - -Offset 0x063E2 (25570): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063E3 (25571): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063E4 (25572): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063E5 (25573): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063E6 (25574): - Valores distintos (4): 0x29, 0x2A, 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2A -> 127 veces - 0x29 -> 77 veces - 0x52 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063E7 (25575): - Valores distintos (4): 0x00, 0x36, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x36 -> 127 veces - 0x00 -> 77 veces - 0x3F -> 21 veces - 0xFF -> 9 veces - -Offset 0x063E8 (25576): - Valores distintos (5): 0x00, 0x21, 0x26, 0x2D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x26 -> 102 veces - 0x00 -> 77 veces - 0x21 -> 25 veces - 0x2D -> 21 veces - 0xFF -> 9 veces - -Offset 0x063E9 (25577): - Valores distintos (4): 0x0A, 0x15, 0x1B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 177 veces - 0x15 -> 27 veces - 0x1B -> 21 veces - 0xFF -> 9 veces - -Offset 0x063EA (25578): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 177 veces - 0x00 -> 48 veces - 0xFF -> 9 veces - -Offset 0x063EB (25579): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063EC (25580): - Valores distintos (6): 0x3F, 0x63, 0x6C, 0xB0, 0xB2, 0xFF - Clasificación: small_state - Más frecuentes: - 0x63 -> 77 veces - 0xB2 -> 75 veces - 0xB0 -> 27 veces - 0x6C -> 25 veces - 0x3F -> 21 veces - -Offset 0x063ED (25581): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063EE (25582): - Valores distintos (5): 0x07, 0x0D, 0x14, 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 102 veces - 0x0D -> 75 veces - 0x14 -> 27 veces - 0x24 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063EF (25583): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063F0 (25584): - Valores distintos (2): 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0B -> 225 veces - 0xFF -> 9 veces - -Offset 0x063F1 (25585): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063F2 (25586): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063F3 (25587): - Valores distintos (4): 0x01, 0x04, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 100 veces - 0xFF -> 86 veces - 0x01 -> 27 veces - 0x10 -> 21 veces - -Offset 0x063F4 (25588): - Valores distintos (6): 0x3F, 0x63, 0x6C, 0xB2, 0xC8, 0xFF - Clasificación: small_state - Más frecuentes: - 0x63 -> 77 veces - 0xB2 -> 75 veces - 0xC8 -> 27 veces - 0x6C -> 25 veces - 0x3F -> 21 veces - -Offset 0x063F5 (25589): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063F6 (25590): - Valores distintos (5): 0x07, 0x0D, 0x14, 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 102 veces - 0x0D -> 75 veces - 0x14 -> 27 veces - 0x24 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063F7 (25591): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063F8 (25592): - Valores distintos (6): 0x4F, 0x54, 0x62, 0x84, 0x85, 0xFF - Clasificación: small_state - Más frecuentes: - 0x54 -> 77 veces - 0x84 -> 75 veces - 0x85 -> 27 veces - 0x62 -> 25 veces - 0x4F -> 21 veces - -Offset 0x063F9 (25593): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063FA (25594): - Valores distintos (6): 0x17, 0x41, 0x54, 0x82, 0xAE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 77 veces - 0x82 -> 75 veces - 0xAE -> 27 veces - 0x54 -> 25 veces - 0x17 -> 21 veces - -Offset 0x063FB (25595): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063FC (25596): - Valores distintos (5): 0x05, 0x06, 0x09, 0x1A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 77 veces - 0x05 -> 75 veces - 0x06 -> 52 veces - 0x1A -> 21 veces - 0xFF -> 9 veces - -Offset 0x063FD (25597): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x063FE (25598): - Valores distintos (4): 0x15, 0x1F, 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x15 -> 177 veces - 0x1F -> 27 veces - 0x46 -> 21 veces - 0xFF -> 9 veces - -Offset 0x063FF (25599): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06400 (25600): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06401 (25601): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06402 (25602): - Valores distintos (2): 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06403 (25603): - Valores distintos (3): 0x04, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 204 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06404 (25604): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06405 (25605): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06406 (25606): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06407 (25607): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06408 (25608): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06409 (25609): - Valores distintos (3): 0x02, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 204 veces - 0x07 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0640A (25610): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0640B (25611): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0640C (25612): - Valores distintos (3): 0x37, 0x3C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x37 -> 198 veces - 0x3C -> 27 veces - 0xFF -> 9 veces - -Offset 0x0640D (25613): - Valores distintos (2): 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0640E (25614): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0640F (25615): - Valores distintos (5): 0x00, 0x02, 0x04, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 100 veces - 0x04 -> 77 veces - 0x02 -> 27 veces - 0x0E -> 21 veces - 0xFF -> 9 veces - -Offset 0x06410 (25616): - Valores distintos (2): 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5A -> 225 veces - 0xFF -> 9 veces - -Offset 0x06411 (25617): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06412 (25618): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06413 (25619): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06414 (25620): - Valores distintos (6): 0x3F, 0x63, 0x6C, 0xB2, 0xC8, 0xFF - Clasificación: small_state - Más frecuentes: - 0x63 -> 77 veces - 0xB2 -> 75 veces - 0xC8 -> 27 veces - 0x6C -> 25 veces - 0x3F -> 21 veces - -Offset 0x06415 (25621): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06416 (25622): - Valores distintos (5): 0x07, 0x0D, 0x14, 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 102 veces - 0x0D -> 75 veces - 0x14 -> 27 veces - 0x24 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06417 (25623): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06418 (25624): - Valores distintos (6): 0x3A, 0x40, 0x62, 0x6D, 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3A -> 77 veces - 0x62 -> 75 veces - 0x6D -> 27 veces - 0x40 -> 25 veces - 0xB9 -> 21 veces - -Offset 0x06419 (25625): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0641A (25626): - Valores distintos (6): 0x2C, 0x32, 0x5B, 0x63, 0x93, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2C -> 77 veces - 0x5B -> 75 veces - 0x63 -> 27 veces - 0x32 -> 25 veces - 0x93 -> 21 veces - -Offset 0x0641B (25627): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0641C (25628): - Valores distintos (4): 0x11, 0x14, 0x35, 0xFF - Clasificación: small_state - Más frecuentes: - 0x11 -> 177 veces - 0x14 -> 27 veces - 0x35 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0641D (25629): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0641E (25630): - Valores distintos (4): 0x15, 0x1F, 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x15 -> 177 veces - 0x1F -> 27 veces - 0x46 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0641F (25631): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06420 (25632): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06421 (25633): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06422 (25634): - Valores distintos (2): 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06423 (25635): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06424 (25636): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06425 (25637): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06426 (25638): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06427 (25639): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06428 (25640): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06429 (25641): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0642A (25642): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0642B (25643): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0642C (25644): - Valores distintos (2): 0x37, 0xFF - Clasificación: small_state - Más frecuentes: - 0x37 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0642D (25645): - Valores distintos (2): 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0642E (25646): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0642F (25647): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06430 (25648): - Valores distintos (2): 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5A -> 225 veces - 0xFF -> 9 veces - -Offset 0x06431 (25649): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06432 (25650): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06433 (25651): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06434 (25652): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06435 (25653): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06436 (25654): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06437 (25655): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06438 (25656): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06439 (25657): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0643A (25658): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0643B (25659): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0643C (25660): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0643D (25661): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0643E (25662): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0643F (25663): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06440 (25664): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06441 (25665): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06442 (25666): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06443 (25667): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06444 (25668): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06445 (25669): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06446 (25670): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06447 (25671): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06448 (25672): - Valores distintos (2): 0x9B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06449 (25673): - Valores distintos (2): 0x5B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5B -> 225 veces - 0xFF -> 9 veces - -Offset 0x0644A (25674): - Valores distintos (3): 0x00, 0x5C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5C -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x0644B (25675): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x0644C (25676): - Valores distintos (3): 0x00, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x69 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0644D (25677): - Valores distintos (3): 0x00, 0x5D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x5D -> 21 veces - 0xFF -> 9 veces - -Offset 0x0644E (25678): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0644F (25679): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06450 (25680): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06451 (25681): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06452 (25682): - Valores distintos (4): 0x00, 0x0F, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x0F -> 102 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06453 (25683): - Valores distintos (3): 0x00, 0x1A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1A -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06454 (25684): - Valores distintos (3): 0x00, 0x99, 0xFF - Clasificación: small_state - Más frecuentes: - 0x99 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06455 (25685): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06456 (25686): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06457 (25687): - Valores distintos (3): 0x00, 0xAC, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xAC -> 21 veces - 0xFF -> 9 veces - -Offset 0x06458 (25688): - Valores distintos (3): 0x00, 0xCB, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xCB -> 21 veces - 0xFF -> 9 veces - -Offset 0x06459 (25689): - Valores distintos (3): 0x00, 0x9A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x9A -> 21 veces - 0xFF -> 9 veces - -Offset 0x0645A (25690): - Valores distintos (3): 0x00, 0x9D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x9D -> 21 veces - 0xFF -> 9 veces - -Offset 0x0645B (25691): - Valores distintos (3): 0x00, 0xAB, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xAB -> 21 veces - 0xFF -> 9 veces - -Offset 0x0645C (25692): - Valores distintos (5): 0x00, 0x0D, 0x15, 0x22, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0D -> 100 veces - 0x00 -> 77 veces - 0x15 -> 27 veces - 0x22 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0645D (25693): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 104 veces - 0x04 -> 100 veces - 0xFF -> 30 veces - -Offset 0x0645E (25694): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 27 veces - 0xFF -> 9 veces - -Offset 0x0645F (25695): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 100 veces - 0x00 -> 77 veces - 0xFF -> 57 veces - -Offset 0x06460 (25696): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 100 veces - 0x00 -> 77 veces - 0xFF -> 57 veces - -Offset 0x06461 (25697): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 104 veces - 0xFD -> 100 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06462 (25698): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFD -> 100 veces - 0x00 -> 98 veces - 0x02 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06463 (25699): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06464 (25700): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06465 (25701): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06466 (25702): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06467 (25703): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06468 (25704): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06469 (25705): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0646A (25706): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0646B (25707): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0646C (25708): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0646D (25709): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0646E (25710): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0646F (25711): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06470 (25712): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06471 (25713): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06472 (25714): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06473 (25715): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06474 (25716): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06475 (25717): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06476 (25718): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06477 (25719): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06478 (25720): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06479 (25721): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0647A (25722): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0647B (25723): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0647C (25724): - Valores distintos (2): 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x54 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0647D (25725): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0647E (25726): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0647F (25727): - Valores distintos (2): 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x70 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06480 (25728): - Valores distintos (2): 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06481 (25729): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06482 (25730): - Valores distintos (4): 0x06, 0x08, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 217 veces - 0xFF -> 9 veces - 0x06 -> 5 veces - 0x08 -> 3 veces - -Offset 0x06483 (25731): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 216 veces - 0xFF -> 9 veces - 0x01 -> 9 veces - -Offset 0x06484 (25732): - Valores distintos (5): 0x20, 0x64, 0x81, 0xCC, 0xFF - Clasificación: small_state - Más frecuentes: - 0x81 -> 216 veces - 0xFF -> 9 veces - 0xCC -> 5 veces - 0x20 -> 3 veces - 0x64 -> 1 veces - -Offset 0x06485 (25733): - Valores distintos (4): 0x00, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 217 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0x02 -> 3 veces - -Offset 0x06486 (25734): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06487 (25735): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06488 (25736): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06489 (25737): - Valores distintos (3): 0x00, 0x20, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 197 veces - 0x20 -> 28 veces - 0xFF -> 9 veces - -Offset 0x0648A (25738): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0648B (25739): - Valores distintos (3): 0x32, 0x33, 0xFF - Clasificación: small_state - Más frecuentes: - 0x33 -> 220 veces - 0xFF -> 9 veces - 0x32 -> 5 veces - -Offset 0x0648C (25740): - Valores distintos (3): 0x21, 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 220 veces - 0xFF -> 9 veces - 0x21 -> 5 veces - -Offset 0x0648D (25741): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0648E (25742): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0648F (25743): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06490 (25744): - Valores distintos (5): 0x01, 0x27, 0x31, 0x36, 0xFF - Clasificación: small_state - Más frecuentes: - 0x36 -> 168 veces - 0x01 -> 28 veces - 0x31 -> 24 veces - 0xFF -> 9 veces - 0x27 -> 5 veces - -Offset 0x06491 (25745): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06492 (25746): - Valores distintos (4): 0x18, 0x20, 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 217 veces - 0xFF -> 9 veces - 0x18 -> 5 veces - 0x20 -> 3 veces - -Offset 0x06493 (25747): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06494 (25748): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06495 (25749): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06496 (25750): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 203 veces - 0x01 -> 22 veces - 0xFF -> 9 veces - -Offset 0x06498 (25752): - Valores distintos (4): 0x29, 0x31, 0x36, 0xFF - Clasificación: small_state - Más frecuentes: - 0x36 -> 195 veces - 0x31 -> 25 veces - 0xFF -> 9 veces - 0x29 -> 5 veces - -Offset 0x06499 (25753): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0649A (25754): - Valores distintos (4): 0x18, 0x20, 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 217 veces - 0xFF -> 9 veces - 0x18 -> 5 veces - 0x20 -> 3 veces - -Offset 0x0649B (25755): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0649C (25756): - Valores distintos (4): 0x1B, 0x21, 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x24 -> 217 veces - 0xFF -> 9 veces - 0x1B -> 5 veces - 0x21 -> 3 veces - -Offset 0x0649D (25757): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0649E (25758): - Valores distintos (4): 0x16, 0x1F, 0x22, 0xFF - Clasificación: small_state - Más frecuentes: - 0x22 -> 217 veces - 0xFF -> 9 veces - 0x16 -> 5 veces - 0x1F -> 3 veces - -Offset 0x0649F (25759): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064A0 (25760): - Valores distintos (3): 0x08, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 220 veces - 0xFF -> 9 veces - 0x09 -> 5 veces - -Offset 0x064A1 (25761): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064A2 (25762): - Valores distintos (4): 0x18, 0x1D, 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 217 veces - 0xFF -> 9 veces - 0x18 -> 5 veces - 0x1D -> 3 veces - -Offset 0x064A3 (25763): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064A4 (25764): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064A5 (25765): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064A6 (25766): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064A7 (25767): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064A8 (25768): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064A9 (25769): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064AA (25770): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064AB (25771): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064AC (25772): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064AD (25773): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064AE (25774): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064AF (25775): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B0 (25776): - Valores distintos (2): 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B1 (25777): - Valores distintos (2): 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B2 (25778): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B3 (25779): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B4 (25780): - Valores distintos (2): 0x5F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5F -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B5 (25781): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B6 (25782): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B7 (25783): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064B8 (25784): - Valores distintos (4): 0x29, 0x31, 0x36, 0xFF - Clasificación: small_state - Más frecuentes: - 0x36 -> 217 veces - 0xFF -> 9 veces - 0x29 -> 5 veces - 0x31 -> 3 veces - -Offset 0x064B9 (25785): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064BA (25786): - Valores distintos (4): 0x18, 0x20, 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 217 veces - 0xFF -> 9 veces - 0x18 -> 5 veces - 0x20 -> 3 veces - -Offset 0x064BB (25787): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064BC (25788): - Valores distintos (4): 0x15, 0x1B, 0x1E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1E -> 217 veces - 0xFF -> 9 veces - 0x15 -> 5 veces - 0x1B -> 3 veces - -Offset 0x064BD (25789): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064BE (25790): - Valores distintos (4): 0x10, 0x15, 0x18, 0xFF - Clasificación: small_state - Más frecuentes: - 0x18 -> 217 veces - 0xFF -> 9 veces - 0x10 -> 5 veces - 0x15 -> 3 veces - -Offset 0x064BF (25791): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064C0 (25792): - Valores distintos (3): 0x0E, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 220 veces - 0xFF -> 9 veces - 0x0E -> 5 veces - -Offset 0x064C1 (25793): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064C2 (25794): - Valores distintos (4): 0x18, 0x1D, 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 217 veces - 0xFF -> 9 veces - 0x18 -> 5 veces - 0x1D -> 3 veces - -Offset 0x064C3 (25795): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064C4 (25796): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064C5 (25797): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064C6 (25798): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064C7 (25799): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064C8 (25800): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064C9 (25801): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064CA (25802): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064CB (25803): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064CC (25804): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064CD (25805): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064CE (25806): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064CF (25807): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D0 (25808): - Valores distintos (2): 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D1 (25809): - Valores distintos (2): 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D2 (25810): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D3 (25811): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D4 (25812): - Valores distintos (2): 0x5F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5F -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D5 (25813): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D6 (25814): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D7 (25815): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D8 (25816): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064D9 (25817): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064DA (25818): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064DB (25819): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064DC (25820): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064DD (25821): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064DE (25822): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064DF (25823): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E0 (25824): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E1 (25825): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E2 (25826): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E3 (25827): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E4 (25828): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E5 (25829): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E6 (25830): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E7 (25831): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E8 (25832): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064E9 (25833): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064EA (25834): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064EB (25835): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064EC (25836): - Valores distintos (2): 0x5B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5B -> 225 veces - 0xFF -> 9 veces - -Offset 0x064ED (25837): - Valores distintos (2): 0x5E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5E -> 225 veces - 0xFF -> 9 veces - -Offset 0x064EE (25838): - Valores distintos (3): 0x00, 0x67, 0xFF - Clasificación: small_state - Más frecuentes: - 0x67 -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x064EF (25839): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F0 (25840): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F1 (25841): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F2 (25842): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F3 (25843): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F4 (25844): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F5 (25845): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F6 (25846): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F7 (25847): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F8 (25848): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064F9 (25849): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064FA (25850): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064FB (25851): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064FC (25852): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064FD (25853): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064FE (25854): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x064FF (25855): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06500 (25856): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06501 (25857): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06502 (25858): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06503 (25859): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06504 (25860): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06505 (25861): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06506 (25862): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06507 (25863): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06508 (25864): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06509 (25865): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0650A (25866): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0650B (25867): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0650C (25868): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0650D (25869): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0650E (25870): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0650F (25871): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06510 (25872): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06511 (25873): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06512 (25874): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06513 (25875): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06514 (25876): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06515 (25877): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06516 (25878): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06517 (25879): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06518 (25880): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06519 (25881): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0651A (25882): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0651B (25883): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0651C (25884): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0651D (25885): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0651E (25886): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0651F (25887): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06520 (25888): - Valores distintos (2): 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06521 (25889): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06522 (25890): - Valores distintos (2): 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x69 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06523 (25891): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06524 (25892): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06525 (25893): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06526 (25894): - Valores distintos (9): 0x07, 0x08, 0x09, 0x15, 0x16, 0x21, 0x2E, 0x2F, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x09 -> 94 veces - 0x16 -> 72 veces - 0x21 -> 27 veces - 0x2F -> 12 veces - 0xFF -> 9 veces - -Offset 0x06527 (25895): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 127 veces - 0x00 -> 98 veces - 0xFF -> 9 veces - -Offset 0x06528 (25896): - Valores distintos (10): 0x21, 0x33, 0x5E, 0x74, 0x7B, 0x9C, 0xBF, 0xF1, 0xFE, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x7B -> 93 veces - 0x33 -> 72 veces - 0x74 -> 27 veces - 0xBF -> 12 veces - 0xFF -> 9 veces - -Offset 0x06529 (25897): - Valores distintos (8): 0x01, 0x02, 0x0A, 0x33, 0x40, 0x54, 0xD2, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 94 veces - 0x40 -> 72 veces - 0x0A -> 27 veces - 0xD2 -> 12 veces - 0xFF -> 9 veces - -Offset 0x0652A (25898): - Valores distintos (4): 0x00, 0x01, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0652B (25899): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0652C (25900): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0652D (25901): - Valores distintos (3): 0x00, 0x20, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 224 veces - 0xFF -> 9 veces - 0x20 -> 1 veces - -Offset 0x0652E (25902): - Valores distintos (7): 0x02, 0x03, 0x04, 0x09, 0x12, 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 94 veces - 0x09 -> 75 veces - 0x12 -> 27 veces - 0x43 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0652F (25903): - Valores distintos (6): 0x32, 0x33, 0x38, 0x3C, 0x40, 0xFF - Clasificación: small_state - Más frecuentes: - 0x33 -> 97 veces - 0x38 -> 75 veces - 0x3C -> 27 veces - 0x40 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06530 (25904): - Valores distintos (5): 0x23, 0x26, 0x2A, 0x2D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 102 veces - 0x26 -> 75 veces - 0x2A -> 27 veces - 0x2D -> 21 veces - 0xFF -> 9 veces - -Offset 0x06531 (25905): - Valores distintos (5): 0x02, 0x10, 0x14, 0x1A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 102 veces - 0x10 -> 75 veces - 0x14 -> 27 veces - 0x1A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06532 (25906): - Valores distintos (4): 0x00, 0x04, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 36 veces - 0x0C -> 12 veces - 0xFF -> 9 veces - -Offset 0x06533 (25907): - Valores distintos (4): 0x00, 0x02, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 36 veces - 0x0B -> 12 veces - 0xFF -> 9 veces - -Offset 0x06534 (25908): - Valores distintos (10): 0x01, 0x33, 0x38, 0x3A, 0x3E, 0x77, 0x7C, 0x7F, 0xA1, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x3E -> 72 veces - 0x7C -> 72 veces - 0x7F -> 27 veces - 0x38 -> 21 veces - 0xA1 -> 21 veces - -Offset 0x06535 (25909): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06536 (25910): - Valores distintos (6): 0x0D, 0x10, 0x12, 0x24, 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x12 -> 94 veces - 0x24 -> 75 veces - 0x27 -> 48 veces - 0xFF -> 9 veces - 0x0D -> 5 veces - -Offset 0x06537 (25911): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06538 (25912): - Valores distintos (3): 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 203 veces - 0x01 -> 22 veces - 0xFF -> 9 veces - -Offset 0x06539 (25913): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0653A (25914): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 203 veces - 0x01 -> 22 veces - 0xFF -> 9 veces - -Offset 0x0653B (25915): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 111 veces - 0x00 -> 75 veces - 0x0F -> 48 veces - -Offset 0x0653C (25916): - Valores distintos (8): 0x33, 0x38, 0x3A, 0x3E, 0x77, 0x7C, 0xA1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3E -> 72 veces - 0x7C -> 72 veces - 0xA1 -> 48 veces - 0x38 -> 22 veces - 0xFF -> 9 veces - -Offset 0x0653D (25917): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0653E (25918): - Valores distintos (6): 0x0D, 0x10, 0x12, 0x24, 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x12 -> 94 veces - 0x24 -> 75 veces - 0x27 -> 48 veces - 0xFF -> 9 veces - 0x0D -> 5 veces - -Offset 0x0653F (25919): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06540 (25920): - Valores distintos (9): 0x0F, 0x11, 0x24, 0x29, 0x32, 0x6D, 0x74, 0xE1, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x32 -> 94 veces - 0x74 -> 72 veces - 0xE1 -> 27 veces - 0x11 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06541 (25921): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06542 (25922): - Valores distintos (8): 0x1B, 0x1C, 0x21, 0x23, 0x6E, 0x72, 0xC6, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 94 veces - 0x72 -> 72 veces - 0xC6 -> 27 veces - 0x1B -> 21 veces - 0xFF -> 9 veces - -Offset 0x06543 (25923): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06544 (25924): - Valores distintos (9): 0x0E, 0x0F, 0x10, 0x1C, 0x1D, 0x31, 0x52, 0x55, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x0E -> 94 veces - 0x1D -> 72 veces - 0x31 -> 27 veces - 0x55 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06545 (25925): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06546 (25926): - Valores distintos (8): 0x19, 0x1D, 0x1E, 0x35, 0x6B, 0x8A, 0xA6, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1E -> 94 veces - 0x35 -> 75 veces - 0x6B -> 27 veces - 0x8A -> 12 veces - 0xFF -> 9 veces - -Offset 0x06547 (25927): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06548 (25928): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06549 (25929): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0654A (25930): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0654B (25931): - Valores distintos (5): 0x02, 0x05, 0x06, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 177 veces - 0x05 -> 27 veces - 0x07 -> 12 veces - 0xFF -> 9 veces - 0x06 -> 9 veces - -Offset 0x0654C (25932): - Valores distintos (3): 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 198 veces - 0x04 -> 27 veces - 0xFF -> 9 veces - -Offset 0x0654D (25933): - Valores distintos (3): 0x02, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 213 veces - 0x07 -> 12 veces - 0xFF -> 9 veces - -Offset 0x0654E (25934): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0654F (25935): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06550 (25936): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06551 (25937): - Valores distintos (3): 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 204 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06552 (25938): - Valores distintos (3): 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06553 (25939): - Valores distintos (3): 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06554 (25940): - Valores distintos (2): 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06555 (25941): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06556 (25942): - Valores distintos (3): 0x05, 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 204 veces - 0x0D -> 21 veces - 0xFF -> 9 veces - -Offset 0x06557 (25943): - Valores distintos (2): 0x19, 0xFF - Clasificación: small_state - Más frecuentes: - 0x19 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06558 (25944): - Valores distintos (2): 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06559 (25945): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0655A (25946): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0655B (25947): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0655C (25948): - Valores distintos (7): 0x33, 0x3A, 0x3E, 0x77, 0x7C, 0xA1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3E -> 94 veces - 0x7C -> 72 veces - 0xA1 -> 48 veces - 0xFF -> 9 veces - 0x33 -> 5 veces - -Offset 0x0655D (25949): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0655E (25950): - Valores distintos (6): 0x0D, 0x10, 0x12, 0x24, 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x12 -> 94 veces - 0x24 -> 75 veces - 0x27 -> 48 veces - 0xFF -> 9 veces - 0x0D -> 5 veces - -Offset 0x0655F (25951): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06560 (25952): - Valores distintos (9): 0x1E, 0x21, 0x23, 0x47, 0x4E, 0x81, 0xBA, 0xBC, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x23 -> 94 veces - 0x4E -> 72 veces - 0x81 -> 27 veces - 0xBC -> 12 veces - 0xFF -> 9 veces - -Offset 0x06561 (25953): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06562 (25954): - Valores distintos (9): 0x14, 0x17, 0x19, 0x33, 0x37, 0x60, 0x96, 0x9B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x19 -> 94 veces - 0x37 -> 72 veces - 0x60 -> 27 veces - 0x9B -> 12 veces - 0xFF -> 9 veces - -Offset 0x06563 (25955): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06564 (25956): - Valores distintos (8): 0x16, 0x17, 0x28, 0x29, 0x3F, 0x5F, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x17 -> 97 veces - 0x29 -> 72 veces - 0x3F -> 27 veces - 0x62 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06565 (25957): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06566 (25958): - Valores distintos (8): 0x19, 0x1D, 0x1E, 0x35, 0x4D, 0x83, 0x85, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1E -> 94 veces - 0x35 -> 75 veces - 0x4D -> 27 veces - 0x85 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06567 (25959): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06568 (25960): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06569 (25961): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0656A (25962): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0656B (25963): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0656C (25964): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0656D (25965): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0656E (25966): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0656F (25967): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06570 (25968): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06571 (25969): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06572 (25970): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06573 (25971): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06574 (25972): - Valores distintos (2): 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06575 (25973): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06576 (25974): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06577 (25975): - Valores distintos (2): 0x19, 0xFF - Clasificación: small_state - Más frecuentes: - 0x19 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06578 (25976): - Valores distintos (2): 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06579 (25977): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0657A (25978): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0657B (25979): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0657C (25980): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0657D (25981): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0657E (25982): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0657F (25983): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06580 (25984): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06581 (25985): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06582 (25986): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06583 (25987): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06584 (25988): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06585 (25989): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06586 (25990): - Valores distintos (3): 0x00, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x58 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06587 (25991): - Valores distintos (3): 0x00, 0x57, 0xFF - Clasificación: small_state - Más frecuentes: - 0x57 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06588 (25992): - Valores distintos (3): 0x00, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x54 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06589 (25993): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0658A (25994): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0658B (25995): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0658C (25996): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0658D (25997): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0658E (25998): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0658F (25999): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06590 (26000): - Valores distintos (2): 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06591 (26001): - Valores distintos (3): 0x00, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x61 -> 217 veces - 0xFF -> 9 veces - 0x00 -> 8 veces - -Offset 0x06592 (26002): - Valores distintos (3): 0x00, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x62 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06593 (26003): - Valores distintos (3): 0x00, 0x40, 0xFF - Clasificación: small_state - Más frecuentes: - 0x40 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06594 (26004): - Valores distintos (3): 0x00, 0x6A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6A -> 48 veces - 0xFF -> 9 veces - -Offset 0x06595 (26005): - Valores distintos (3): 0x00, 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x63 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06596 (26006): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06597 (26007): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06598 (26008): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06599 (26009): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0659A (26010): - Valores distintos (4): 0x00, 0x16, 0x45, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 173 veces - 0x16 -> 48 veces - 0xFF -> 9 veces - 0x45 -> 4 veces - -Offset 0x0659B (26011): - Valores distintos (3): 0x00, 0x2A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x2A -> 48 veces - 0xFF -> 9 veces - -Offset 0x0659C (26012): - Valores distintos (3): 0x00, 0x9C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x9C -> 21 veces - 0xFF -> 9 veces - -Offset 0x0659D (26013): - Valores distintos (3): 0x00, 0x2B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x2B -> 21 veces - 0xFF -> 9 veces - -Offset 0x0659E (26014): - Valores distintos (3): 0x00, 0x13, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x13 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0659F (26015): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065A0 (26016): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065A1 (26017): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065A2 (26018): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065A3 (26019): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065A4 (26020): - Valores distintos (4): 0x00, 0x14, 0x1B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x14 -> 75 veces - 0x1B -> 48 veces - 0xFF -> 9 veces - -Offset 0x065A5 (26021): - Valores distintos (4): 0x00, 0x02, 0xFA, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x02 -> 75 veces - 0xFA -> 48 veces - 0xFF -> 9 veces - -Offset 0x065A6 (26022): - Valores distintos (4): 0x00, 0xFA, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0xFE -> 75 veces - 0xFA -> 48 veces - 0xFF -> 9 veces - -Offset 0x065A7 (26023): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x065A8 (26024): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x065A9 (26025): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x065AA (26026): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0xFD -> 75 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x065AB (26027): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065AC (26028): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065AD (26029): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065AE (26030): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065AF (26031): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B0 (26032): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B1 (26033): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B2 (26034): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B3 (26035): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B4 (26036): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B5 (26037): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B6 (26038): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B7 (26039): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B8 (26040): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065B9 (26041): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065BA (26042): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065BB (26043): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065BC (26044): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065BD (26045): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065BE (26046): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065BF (26047): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C0 (26048): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C1 (26049): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C2 (26050): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C3 (26051): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C4 (26052): - Valores distintos (2): 0x4D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4D -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C5 (26053): - Valores distintos (2): 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6F -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C6 (26054): - Valores distintos (2): 0x6D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6D -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C7 (26055): - Valores distintos (2): 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6F -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C8 (26056): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065C9 (26057): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065CA (26058): - Valores distintos (9): 0x0A, 0x0E, 0x0F, 0x14, 0x16, 0x22, 0x2C, 0x2D, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x16 -> 72 veces - 0x0A -> 52 veces - 0x0F -> 42 veces - 0x22 -> 27 veces - 0x2D -> 12 veces - -Offset 0x065CB (26059): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x065CC (26060): - Valores distintos (10): 0x0F, 0x51, 0x71, 0xAF, 0xBB, 0xDA, 0xE8, 0xF6, 0xF8, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x71 -> 72 veces - 0xE8 -> 52 veces - 0x0F -> 27 veces - 0x51 -> 25 veces - 0xF6 -> 17 veces - -Offset 0x065CD (26061): - Valores distintos (10): 0x03, 0x0D, 0x10, 0x12, 0x2E, 0x35, 0x3B, 0x51, 0xC6, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x3B -> 72 veces - 0x03 -> 52 veces - 0x51 -> 27 veces - 0x12 -> 25 veces - 0x10 -> 17 veces - -Offset 0x065CE (26062): - Valores distintos (4): 0x00, 0x01, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x065CF (26063): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065D0 (26064): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065D1 (26065): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065D2 (26066): - Valores distintos (5): 0x46, 0x4A, 0x4E, 0x50, 0xFF - Clasificación: small_state - Más frecuentes: - 0x46 -> 102 veces - 0x4A -> 75 veces - 0x4E -> 27 veces - 0x50 -> 21 veces - 0xFF -> 9 veces - -Offset 0x065D3 (26067): - Valores distintos (5): 0x00, 0x32, 0x36, 0x3C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x36 -> 75 veces - 0x3C -> 48 veces - 0x32 -> 25 veces - 0xFF -> 9 veces - -Offset 0x065D4 (26068): - Valores distintos (4): 0x26, 0x2B, 0x2F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x26 -> 177 veces - 0x2B -> 27 veces - 0x2F -> 21 veces - 0xFF -> 9 veces - -Offset 0x065D5 (26069): - Valores distintos (6): 0x06, 0x08, 0x10, 0x16, 0x18, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 75 veces - 0x06 -> 52 veces - 0x08 -> 50 veces - 0x16 -> 27 veces - 0x18 -> 21 veces - -Offset 0x065D6 (26070): - Valores distintos (4): 0x00, 0x02, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 125 veces - 0x00 -> 52 veces - 0x0B -> 48 veces - 0xFF -> 9 veces - -Offset 0x065D7 (26071): - Valores distintos (6): 0x00, 0x09, 0x0B, 0x0C, 0x19, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0B -> 75 veces - 0x00 -> 61 veces - 0x09 -> 50 veces - 0x0C -> 27 veces - 0x19 -> 12 veces - -Offset 0x065D8 (26072): - Valores distintos (9): 0x34, 0x45, 0x49, 0x5E, 0x65, 0x84, 0xBD, 0xBF, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x65 -> 72 veces - 0x34 -> 52 veces - 0x49 -> 42 veces - 0x84 -> 27 veces - 0xBF -> 12 veces - -Offset 0x065D9 (26073): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065DA (26074): - Valores distintos (9): 0x28, 0x35, 0x38, 0x49, 0x4F, 0x74, 0xA6, 0xAB, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x4F -> 72 veces - 0x28 -> 52 veces - 0x38 -> 42 veces - 0x74 -> 27 veces - 0xAB -> 12 veces - -Offset 0x065DB (26075): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065DC (26076): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065DD (26077): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065DE (26078): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065DF (26079): - Valores distintos (4): 0x03, 0x09, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 111 veces - 0x03 -> 75 veces - 0x0C -> 27 veces - 0x09 -> 21 veces - -Offset 0x065E0 (26080): - Valores distintos (9): 0x34, 0x45, 0x49, 0x5E, 0x65, 0x9F, 0xBD, 0xBF, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x65 -> 72 veces - 0x34 -> 52 veces - 0x49 -> 42 veces - 0x9F -> 27 veces - 0xBF -> 12 veces - -Offset 0x065E1 (26081): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065E2 (26082): - Valores distintos (9): 0x28, 0x35, 0x38, 0x49, 0x4F, 0x74, 0xA6, 0xAB, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x4F -> 72 veces - 0x28 -> 52 veces - 0x38 -> 42 veces - 0x74 -> 27 veces - 0xAB -> 12 veces - -Offset 0x065E3 (26083): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065E4 (26084): - Valores distintos (9): 0x0A, 0x56, 0x58, 0x5B, 0x61, 0x65, 0x89, 0x91, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x91 -> 72 veces - 0x58 -> 52 veces - 0x65 -> 42 veces - 0x0A -> 27 veces - 0x5B -> 12 veces - -Offset 0x065E5 (26085): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x065E6 (26086): - Valores distintos (9): 0x28, 0x39, 0x3C, 0x3D, 0x62, 0x64, 0xAB, 0xC2, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x64 -> 72 veces - 0x28 -> 52 veces - 0xAB -> 27 veces - 0x3D -> 25 veces - 0xC2 -> 21 veces - -Offset 0x065E7 (26087): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065E8 (26088): - Valores distintos (8): 0x0A, 0x0C, 0x0E, 0x12, 0x22, 0x35, 0x38, 0xFF - Clasificación: small_state - Más frecuentes: - 0x12 -> 72 veces - 0x0A -> 52 veces - 0x0E -> 45 veces - 0x22 -> 27 veces - 0x38 -> 12 veces - -Offset 0x065E9 (26089): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065EA (26090): - Valores distintos (8): 0x32, 0x3F, 0x58, 0x61, 0xA4, 0xDC, 0xE3, 0xFF - Clasificación: small_state - Más frecuentes: - 0x61 -> 72 veces - 0x32 -> 52 veces - 0x3F -> 50 veces - 0xA4 -> 27 veces - 0xE3 -> 12 veces - -Offset 0x065EB (26091): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065EC (26092): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065ED (26093): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065EE (26094): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065EF (26095): - Valores distintos (3): 0x02, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 123 veces - 0x02 -> 102 veces - 0xFF -> 9 veces - -Offset 0x065F0 (26096): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065F1 (26097): - Valores distintos (3): 0x02, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 198 veces - 0x07 -> 27 veces - 0xFF -> 9 veces - -Offset 0x065F2 (26098): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065F3 (26099): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065F4 (26100): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065F5 (26101): - Valores distintos (3): 0x02, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 204 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x065F6 (26102): - Valores distintos (3): 0x02, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 204 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x065F7 (26103): - Valores distintos (3): 0x02, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 204 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x065F8 (26104): - Valores distintos (3): 0x1E, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1E -> 150 veces - 0x28 -> 75 veces - 0xFF -> 9 veces - -Offset 0x065F9 (26105): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065FA (26106): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065FB (26107): - Valores distintos (3): 0x04, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 150 veces - 0x09 -> 75 veces - 0xFF -> 9 veces - -Offset 0x065FC (26108): - Valores distintos (3): 0x46, 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x46 -> 150 veces - 0x4B -> 75 veces - 0xFF -> 9 veces - -Offset 0x065FD (26109): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065FE (26110): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x065FF (26111): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06600 (26112): - Valores distintos (9): 0x34, 0x45, 0x49, 0x5E, 0x65, 0x9F, 0xBD, 0xBF, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x65 -> 72 veces - 0x34 -> 52 veces - 0x49 -> 42 veces - 0x9F -> 27 veces - 0xBF -> 12 veces - -Offset 0x06601 (26113): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06602 (26114): - Valores distintos (9): 0x28, 0x35, 0x38, 0x49, 0x4F, 0x74, 0xA6, 0xAB, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x4F -> 72 veces - 0x28 -> 52 veces - 0x38 -> 42 veces - 0x74 -> 27 veces - 0xAB -> 12 veces - -Offset 0x06603 (26115): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06604 (26116): - Valores distintos (9): 0x1E, 0x27, 0x2B, 0x39, 0x41, 0x67, 0x8B, 0x90, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x41 -> 72 veces - 0x1E -> 52 veces - 0x2B -> 42 veces - 0x67 -> 27 veces - 0x90 -> 12 veces - -Offset 0x06605 (26117): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06606 (26118): - Valores distintos (8): 0x19, 0x1E, 0x21, 0x2B, 0x2D, 0x48, 0x51, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2D -> 72 veces - 0x19 -> 52 veces - 0x21 -> 42 veces - 0x48 -> 27 veces - 0x51 -> 21 veces - -Offset 0x06607 (26119): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06608 (26120): - Valores distintos (9): 0x0F, 0x12, 0x14, 0x18, 0x1C, 0x28, 0x3B, 0x3E, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1C -> 72 veces - 0x0F -> 52 veces - 0x14 -> 42 veces - 0x28 -> 27 veces - 0x3E -> 12 veces - -Offset 0x06609 (26121): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0660A (26122): - Valores distintos (8): 0x32, 0x3F, 0x58, 0x61, 0x9F, 0xDC, 0xE3, 0xFF - Clasificación: small_state - Más frecuentes: - 0x61 -> 72 veces - 0x32 -> 52 veces - 0x3F -> 50 veces - 0x9F -> 27 veces - 0xE3 -> 12 veces - -Offset 0x0660B (26123): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0660C (26124): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0660D (26125): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0660E (26126): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0660F (26127): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06610 (26128): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06611 (26129): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06612 (26130): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06613 (26131): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06614 (26132): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06615 (26133): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06616 (26134): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06617 (26135): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06618 (26136): - Valores distintos (2): 0x1E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1E -> 225 veces - 0xFF -> 9 veces - -Offset 0x06619 (26137): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0661A (26138): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0661B (26139): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0661C (26140): - Valores distintos (2): 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x46 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0661D (26141): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0661E (26142): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0661F (26143): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06620 (26144): - Valores distintos (2): 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x46 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06621 (26145): - Valores distintos (2): 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4B -> 225 veces - 0xFF -> 9 veces - -Offset 0x06622 (26146): - Valores distintos (3): 0x00, 0x47, 0xFF - Clasificación: small_state - Más frecuentes: - 0x47 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06623 (26147): - Valores distintos (3): 0x00, 0x73, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x73 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06624 (26148): - Valores distintos (3): 0x00, 0x4C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4C -> 48 veces - 0xFF -> 9 veces - -Offset 0x06625 (26149): - Valores distintos (3): 0x00, 0x49, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x49 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06626 (26150): - Valores distintos (3): 0x00, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x48 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06627 (26151): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06628 (26152): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06629 (26153): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0662A (26154): - Valores distintos (2): 0x3C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3C -> 225 veces - 0xFF -> 9 veces - -Offset 0x0662B (26155): - Valores distintos (2): 0x44, 0xFF - Clasificación: small_state - Más frecuentes: - 0x44 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0662C (26156): - Valores distintos (2): 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0662D (26157): - Valores distintos (2): 0x57, 0xFF - Clasificación: small_state - Más frecuentes: - 0x57 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0662E (26158): - Valores distintos (3): 0x00, 0x6B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6B -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x0662F (26159): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6C -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x06630 (26160): - Valores distintos (3): 0x00, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x54 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06631 (26161): - Valores distintos (3): 0x00, 0x55, 0xFF - Clasificación: small_state - Más frecuentes: - 0x55 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06632 (26162): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06633 (26163): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06634 (26164): - Valores distintos (3): 0x00, 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x66 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x06635 (26165): - Valores distintos (3): 0x00, 0x6E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6E -> 48 veces - 0xFF -> 9 veces - -Offset 0x06636 (26166): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06637 (26167): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06638 (26168): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06639 (26169): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0663A (26170): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0663B (26171): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0663C (26172): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0663D (26173): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0663E (26174): - Valores distintos (3): 0x00, 0xA6, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xA6 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0663F (26175): - Valores distintos (3): 0x00, 0xAD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xAD -> 48 veces - 0xFF -> 9 veces - -Offset 0x06640 (26176): - Valores distintos (3): 0x00, 0xD8, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xD8 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06641 (26177): - Valores distintos (3): 0x00, 0x45, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x45 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06642 (26178): - Valores distintos (3): 0x00, 0x9E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x9E -> 21 veces - 0xFF -> 9 veces - -Offset 0x06643 (26179): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06644 (26180): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06645 (26181): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06646 (26182): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06647 (26183): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06648 (26184): - Valores distintos (5): 0x00, 0x13, 0x21, 0x2A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x13 -> 75 veces - 0x21 -> 27 veces - 0x2A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06649 (26185): - Valores distintos (3): 0x00, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 129 veces - 0xFF -> 84 veces - 0xFD -> 21 veces - -Offset 0x0664A (26186): - Valores distintos (4): 0x00, 0x03, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 129 veces - 0xFE -> 75 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0664B (26187): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 129 veces - 0x01 -> 96 veces - 0xFF -> 9 veces - -Offset 0x0664C (26188): - Valores distintos (4): 0x00, 0x01, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0xFD -> 21 veces - 0xFF -> 9 veces - -Offset 0x0664D (26189): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 129 veces - 0x01 -> 96 veces - 0xFF -> 9 veces - -Offset 0x0664E (26190): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0664F (26191): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06650 (26192): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06651 (26193): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06652 (26194): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06653 (26195): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06654 (26196): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06655 (26197): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06656 (26198): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06657 (26199): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06658 (26200): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06659 (26201): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0665A (26202): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0665B (26203): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0665C (26204): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0665D (26205): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0665E (26206): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0665F (26207): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06660 (26208): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06661 (26209): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06662 (26210): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06663 (26211): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06664 (26212): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06665 (26213): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06666 (26214): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06667 (26215): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06668 (26216): - Valores distintos (2): 0x50, 0xFF - Clasificación: small_state - Más frecuentes: - 0x50 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06669 (26217): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0666A (26218): - Valores distintos (2): 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x63 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0666B (26219): - Valores distintos (2): 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6F -> 225 veces - 0xFF -> 9 veces - -Offset 0x0666C (26220): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0666D (26221): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0666E (26222): - Valores distintos (5): 0x01, 0x09, 0x13, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 125 veces - 0x01 -> 52 veces - 0x13 -> 27 veces - 0x14 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0666F (26223): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06670 (26224): - Valores distintos (6): 0x00, 0x0B, 0x46, 0x47, 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x46 -> 75 veces - 0x00 -> 52 veces - 0x0B -> 50 veces - 0x47 -> 27 veces - 0x5A -> 21 veces - -Offset 0x06671 (26225): - Valores distintos (5): 0x00, 0x04, 0x31, 0x33, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 125 veces - 0x00 -> 52 veces - 0x31 -> 27 veces - 0x33 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06672 (26226): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06673 (26227): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06674 (26228): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06675 (26229): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06676 (26230): - Valores distintos (3): 0x00, 0x3C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3C -> 48 veces - 0xFF -> 9 veces - -Offset 0x06677 (26231): - Valores distintos (4): 0x00, 0x33, 0x37, 0xFF - Clasificación: small_state - Más frecuentes: - 0x33 -> 125 veces - 0x00 -> 52 veces - 0x37 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06678 (26232): - Valores distintos (3): 0x00, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x26 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06679 (26233): - Valores distintos (4): 0x00, 0x08, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 125 veces - 0x00 -> 52 veces - 0x0B -> 48 veces - 0xFF -> 9 veces - -Offset 0x0667A (26234): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0667B (26235): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0667C (26236): - Valores distintos (5): 0x28, 0x54, 0xB1, 0xD1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x54 -> 125 veces - 0x28 -> 52 veces - 0xB1 -> 27 veces - 0xD1 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0667D (26237): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0667E (26238): - Valores distintos (5): 0x08, 0x24, 0x43, 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x24 -> 125 veces - 0x08 -> 52 veces - 0x43 -> 27 veces - 0x46 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0667F (26239): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06680 (26240): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06681 (26241): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06682 (26242): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06683 (26243): - Valores distintos (3): 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 123 veces - 0xFF -> 61 veces - 0x02 -> 50 veces - -Offset 0x06684 (26244): - Valores distintos (5): 0x28, 0x54, 0xC9, 0xD1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x54 -> 125 veces - 0x28 -> 52 veces - 0xC9 -> 27 veces - 0xD1 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06685 (26245): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06686 (26246): - Valores distintos (5): 0x08, 0x24, 0x43, 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x24 -> 125 veces - 0x08 -> 52 veces - 0x43 -> 27 veces - 0x46 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06687 (26247): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06688 (26248): - Valores distintos (5): 0x12, 0x1C, 0x84, 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1C -> 125 veces - 0x12 -> 52 veces - 0x84 -> 27 veces - 0x88 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06689 (26249): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0668A (26250): - Valores distintos (5): 0x0E, 0x3A, 0x92, 0x98, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3A -> 125 veces - 0x0E -> 52 veces - 0x92 -> 27 veces - 0x98 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0668B (26251): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0668C (26252): - Valores distintos (3): 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0668D (26253): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0668E (26254): - Valores distintos (4): 0x04, 0x1C, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1C -> 125 veces - 0x04 -> 52 veces - 0x1F -> 48 veces - 0xFF -> 9 veces - -Offset 0x0668F (26255): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06690 (26256): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06691 (26257): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06692 (26258): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06693 (26259): - Valores distintos (3): 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 175 veces - 0x01 -> 50 veces - 0xFF -> 9 veces - -Offset 0x06694 (26260): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06695 (26261): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06696 (26262): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06697 (26263): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06698 (26264): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06699 (26265): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0669A (26266): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0669B (26267): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0669C (26268): - Valores distintos (2): 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0669D (26269): - Valores distintos (2): 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0669E (26270): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0669F (26271): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066A0 (26272): - Valores distintos (2): 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5A -> 225 veces - 0xFF -> 9 veces - -Offset 0x066A1 (26273): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066A2 (26274): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066A3 (26275): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066A4 (26276): - Valores distintos (5): 0x28, 0x54, 0xC9, 0xD1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x54 -> 125 veces - 0x28 -> 52 veces - 0xC9 -> 27 veces - 0xD1 -> 21 veces - 0xFF -> 9 veces - -Offset 0x066A5 (26277): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066A6 (26278): - Valores distintos (5): 0x08, 0x24, 0x43, 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x24 -> 125 veces - 0x08 -> 52 veces - 0x43 -> 27 veces - 0x46 -> 21 veces - 0xFF -> 9 veces - -Offset 0x066A7 (26279): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066A8 (26280): - Valores distintos (5): 0x12, 0x1C, 0x4C, 0x50, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1C -> 125 veces - 0x12 -> 52 veces - 0x4C -> 27 veces - 0x50 -> 21 veces - 0xFF -> 9 veces - -Offset 0x066A9 (26281): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066AA (26282): - Valores distintos (5): 0x0E, 0x27, 0x63, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x27 -> 125 veces - 0x0E -> 52 veces - 0x63 -> 27 veces - 0x69 -> 21 veces - 0xFF -> 9 veces - -Offset 0x066AB (26283): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066AC (26284): - Valores distintos (3): 0x03, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 173 veces - 0x03 -> 52 veces - 0xFF -> 9 veces - -Offset 0x066AD (26285): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066AE (26286): - Valores distintos (4): 0x04, 0x1C, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1C -> 125 veces - 0x04 -> 52 veces - 0x1F -> 48 veces - 0xFF -> 9 veces - -Offset 0x066AF (26287): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B0 (26288): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B1 (26289): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B2 (26290): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B3 (26291): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B4 (26292): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B5 (26293): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B6 (26294): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B7 (26295): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B8 (26296): - Valores distintos (2): 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066B9 (26297): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066BA (26298): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066BB (26299): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066BC (26300): - Valores distintos (2): 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066BD (26301): - Valores distintos (2): 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x32 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066BE (26302): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066BF (26303): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C0 (26304): - Valores distintos (2): 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5A -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C1 (26305): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C2 (26306): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C3 (26307): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C4 (26308): - Valores distintos (3): 0x00, 0x47, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x47 -> 21 veces - 0xFF -> 9 veces - -Offset 0x066C5 (26309): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C6 (26310): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C7 (26311): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C8 (26312): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066C9 (26313): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066CA (26314): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066CB (26315): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066CC (26316): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066CD (26317): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066CE (26318): - Valores distintos (3): 0x00, 0x30, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x30 -> 48 veces - 0xFF -> 9 veces - -Offset 0x066CF (26319): - Valores distintos (3): 0x00, 0x33, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x33 -> 48 veces - 0xFF -> 9 veces - -Offset 0x066D0 (26320): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D1 (26321): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D2 (26322): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D3 (26323): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D4 (26324): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D5 (26325): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D6 (26326): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D7 (26327): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D8 (26328): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066D9 (26329): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066DA (26330): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066DB (26331): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066DC (26332): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066DD (26333): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066DE (26334): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066DF (26335): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066E0 (26336): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066E1 (26337): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066E2 (26338): - Valores distintos (3): 0x00, 0x3A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3A -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x066E3 (26339): - Valores distintos (3): 0x00, 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x24 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x066E4 (26340): - Valores distintos (3): 0x00, 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xB9 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x066E5 (26341): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066E6 (26342): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066E7 (26343): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066E8 (26344): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066E9 (26345): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066EA (26346): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066EB (26347): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066EC (26348): - Valores distintos (4): 0x00, 0x01, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 123 veces - 0x00 -> 52 veces - 0x01 -> 50 veces - 0xFF -> 9 veces - -Offset 0x066ED (26349): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 123 veces - 0xFF -> 59 veces - 0x00 -> 52 veces - -Offset 0x066EE (26350): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 175 veces - 0x01 -> 50 veces - 0xFF -> 9 veces - -Offset 0x066EF (26351): - Valores distintos (4): 0x00, 0x01, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 52 veces - 0xFE -> 50 veces - 0xFF -> 9 veces - -Offset 0x066F0 (26352): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 123 veces - 0x00 -> 52 veces - 0x01 -> 50 veces - 0xFF -> 9 veces - -Offset 0x066F1 (26353): - Valores distintos (3): 0x00, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFD -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x066F2 (26354): - Valores distintos (4): 0x00, 0x02, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFD -> 123 veces - 0x00 -> 52 veces - 0x02 -> 50 veces - 0xFF -> 9 veces - -Offset 0x066F3 (26355): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066F4 (26356): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066F5 (26357): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066F6 (26358): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066F7 (26359): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066F8 (26360): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066F9 (26361): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066FA (26362): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066FB (26363): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066FC (26364): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066FD (26365): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066FE (26366): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x066FF (26367): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06700 (26368): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06701 (26369): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06702 (26370): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06703 (26371): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06704 (26372): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06705 (26373): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06706 (26374): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06707 (26375): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06708 (26376): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06709 (26377): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0670A (26378): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0670B (26379): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0670C (26380): - Valores distintos (2): 0x57, 0xFF - Clasificación: small_state - Más frecuentes: - 0x57 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0670D (26381): - Valores distintos (2): 0x68, 0xFF - Clasificación: small_state - Más frecuentes: - 0x68 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0670E (26382): - Valores distintos (2): 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x65 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0670F (26383): - Valores distintos (2): 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x6C -> 225 veces - 0xFF -> 9 veces - -Offset 0x06710 (26384): - Valores distintos (2): 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x70 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06711 (26385): - Valores distintos (2): 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 225 veces - 0xFF -> 9 veces - -Offset 0x06712 (26386): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06713 (26387): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06714 (26388): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06715 (26389): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06716 (26390): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06717 (26391): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06718 (26392): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06719 (26393): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0671A (26394): - Valores distintos (3): 0x00, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x0671B (26395): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0671C (26396): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0671D (26397): - Valores distintos (3): 0x00, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x0671E (26398): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0671F (26399): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06720 (26400): - Valores distintos (3): 0x0F, 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 148 veces - 0x0F -> 77 veces - 0xFF -> 9 veces - -Offset 0x06721 (26401): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06722 (26402): - Valores distintos (2): 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06723 (26403): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06724 (26404): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06725 (26405): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06726 (26406): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06728 (26408): - Valores distintos (3): 0x0F, 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 148 veces - 0x0F -> 77 veces - 0xFF -> 9 veces - -Offset 0x06729 (26409): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0672A (26410): - Valores distintos (2): 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 225 veces - 0xFF -> 9 veces - -Offset 0x0672B (26411): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0672C (26412): - Valores distintos (3): 0x0A, 0x75, 0xFF - Clasificación: small_state - Más frecuentes: - 0x75 -> 148 veces - 0x0A -> 77 veces - 0xFF -> 9 veces - -Offset 0x0672D (26413): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0672E (26414): - Valores distintos (3): 0x08, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x54 -> 148 veces - 0x08 -> 77 veces - 0xFF -> 9 veces - -Offset 0x0672F (26415): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06730 (26416): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 148 veces - 0x04 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06731 (26417): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06732 (26418): - Valores distintos (3): 0x08, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 148 veces - 0x08 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06733 (26419): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06734 (26420): - Valores distintos (2): 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x63 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06735 (26421): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06736 (26422): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06737 (26423): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06738 (26424): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06739 (26425): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0673A (26426): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0673B (26427): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0673C (26428): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0673D (26429): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0673E (26430): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0673F (26431): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06740 (26432): - Valores distintos (2): 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 225 veces - 0xFF -> 9 veces - -Offset 0x06741 (26433): - Valores distintos (2): 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06742 (26434): - Valores distintos (2): 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06743 (26435): - Valores distintos (2): 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 225 veces - 0xFF -> 9 veces - -Offset 0x06744 (26436): - Valores distintos (2): 0x5F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06745 (26437): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06746 (26438): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06747 (26439): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06748 (26440): - Valores distintos (3): 0x0F, 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 148 veces - 0x0F -> 77 veces - 0xFF -> 9 veces - -Offset 0x06749 (26441): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0674A (26442): - Valores distintos (2): 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 225 veces - 0xFF -> 9 veces - -Offset 0x0674B (26443): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0674C (26444): - Valores distintos (3): 0x0A, 0x4A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4A -> 148 veces - 0x0A -> 77 veces - 0xFF -> 9 veces - -Offset 0x0674D (26445): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0674E (26446): - Valores distintos (3): 0x08, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3F -> 148 veces - 0x08 -> 77 veces - 0xFF -> 9 veces - -Offset 0x0674F (26447): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06750 (26448): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 148 veces - 0x04 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06751 (26449): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06752 (26450): - Valores distintos (3): 0x08, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 148 veces - 0x08 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06753 (26451): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06754 (26452): - Valores distintos (2): 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x63 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06755 (26453): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06756 (26454): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06757 (26455): - Valores distintos (2): 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06758 (26456): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06759 (26457): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0675A (26458): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0675B (26459): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0675C (26460): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0675D (26461): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0675E (26462): - Valores distintos (2): 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0675F (26463): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06760 (26464): - Valores distintos (2): 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 225 veces - 0xFF -> 9 veces - -Offset 0x06761 (26465): - Valores distintos (2): 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x64 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06762 (26466): - Valores distintos (2): 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06763 (26467): - Valores distintos (2): 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 225 veces - 0xFF -> 9 veces - -Offset 0x06764 (26468): - Valores distintos (2): 0x5F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5F -> 225 veces - 0xFF -> 9 veces - -Offset 0x06765 (26469): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06766 (26470): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06767 (26471): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06768 (26472): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06769 (26473): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0676A (26474): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0676B (26475): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0676C (26476): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0676D (26477): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0676E (26478): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0676F (26479): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06770 (26480): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06771 (26481): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06772 (26482): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06773 (26483): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06774 (26484): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06775 (26485): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06776 (26486): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06777 (26487): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06778 (26488): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06779 (26489): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0677A (26490): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0677B (26491): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0677C (26492): - Valores distintos (2): 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0677D (26493): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0677E (26494): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0677F (26495): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06780 (26496): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06781 (26497): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06782 (26498): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06783 (26499): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06784 (26500): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06785 (26501): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06786 (26502): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06787 (26503): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06788 (26504): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06789 (26505): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0678A (26506): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0678B (26507): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0678C (26508): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0678D (26509): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0678E (26510): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0678F (26511): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06790 (26512): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06791 (26513): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06792 (26514): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06793 (26515): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06794 (26516): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06795 (26517): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06796 (26518): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06797 (26519): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06798 (26520): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06799 (26521): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0679A (26522): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0679B (26523): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0679C (26524): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0679D (26525): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0679E (26526): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0679F (26527): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A0 (26528): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A1 (26529): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A2 (26530): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A3 (26531): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A4 (26532): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A5 (26533): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A6 (26534): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A7 (26535): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A8 (26536): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067A9 (26537): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067AA (26538): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067AB (26539): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067AC (26540): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067AD (26541): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067AE (26542): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067AF (26543): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067B1 (26545): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067B2 (26546): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067B3 (26547): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067B4 (26548): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067B5 (26549): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067B6 (26550): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067B7 (26551): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067B9 (26553): - Valores distintos (3): 0x00, 0xBE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBE -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x067BA (26554): - Valores distintos (3): 0x00, 0x74, 0xFF - Clasificación: small_state - Más frecuentes: - 0x74 -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x067BB (26555): - Valores distintos (3): 0x1F, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3F -> 220 veces - 0xFF -> 9 veces - 0x1F -> 5 veces - -Offset 0x067BC (26556): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067BD (26557): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067BE (26558): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067BF (26559): - Valores distintos (3): 0x00, 0x5E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x5E -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x067C0 (26560): - Valores distintos (5): 0x00, 0xF1, 0xF3, 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFB -> 216 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0xF1 -> 3 veces - 0xF3 -> 1 veces - -Offset 0x067C1 (26561): - Valores distintos (3): 0x00, 0x91, 0xFF - Clasificación: small_state - Más frecuentes: - 0x91 -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x067C2 (26562): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 226 veces - 0x00 -> 5 veces - 0x01 -> 3 veces - -Offset 0x067C3 (26563): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 225 veces - 0x00 -> 8 veces - 0x03 -> 1 veces - -Offset 0x067C4 (26564): - Valores distintos (4): 0x00, 0xF0, 0xF1, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF1 -> 216 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0xF0 -> 4 veces - -Offset 0x067C5 (26565): - Valores distintos (3): 0x00, 0xC2, 0xFF - Clasificación: small_state - Más frecuentes: - 0xC2 -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x067C6 (26566): - Valores distintos (4): 0x00, 0x0F, 0xCF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xCF -> 217 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0x0F -> 3 veces - -Offset 0x067C7 (26567): - Valores distintos (4): 0x00, 0xC4, 0xC5, 0xFF - Clasificación: small_state - Más frecuentes: - 0xC5 -> 216 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0xC4 -> 4 veces - -Offset 0x067C8 (26568): - Valores distintos (3): 0x00, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 195 veces - 0x00 -> 30 veces - 0xFF -> 9 veces - -Offset 0x067C9 (26569): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 204 veces - 0x00 -> 30 veces - -Offset 0x067CA (26570): - Valores distintos (3): 0x00, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 202 veces - 0x00 -> 31 veces - 0x3F -> 1 veces - -Offset 0x067CB (26571): - Valores distintos (4): 0x00, 0x07, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x7F -> 173 veces - 0x00 -> 32 veces - 0x07 -> 20 veces - 0xFF -> 9 veces - -Offset 0x067CC (26572): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067CD (26573): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067CE (26574): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067CF (26575): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067D0 (26576): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 182 veces - 0x00 -> 52 veces - -Offset 0x067D1 (26577): - Valores distintos (3): 0x00, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x15 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x067D2 (26578): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067D3 (26579): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067D4 (26580): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067D5 (26581): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067D6 (26582): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067D7 (26583): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067D8 (26584): - Valores distintos (3): 0x00, 0x67, 0xFF - Clasificación: small_state - Más frecuentes: - 0x67 -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x067D9 (26585): - Valores distintos (3): 0x00, 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDF -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x067DA (26586): - Valores distintos (3): 0x00, 0x9F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x9F -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x067DB (26587): - Valores distintos (4): 0x00, 0x07, 0xE7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE7 -> 165 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - 0x07 -> 8 veces - -Offset 0x067DC (26588): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 165 veces - 0x00 -> 60 veces - 0xFF -> 9 veces - -Offset 0x067DD (26589): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 174 veces - 0x00 -> 60 veces - -Offset 0x067DE (26590): - Valores distintos (4): 0x00, 0x30, 0x37, 0xFF - Clasificación: small_state - Más frecuentes: - 0x37 -> 148 veces - 0x00 -> 60 veces - 0x30 -> 17 veces - 0xFF -> 9 veces - -Offset 0x067DF (26591): - Valores distintos (4): 0x00, 0x38, 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 148 veces - 0x00 -> 60 veces - 0x38 -> 17 veces - 0xFF -> 9 veces - -Offset 0x067E0 (26592): - Valores distintos (3): 0x00, 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFB -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x067E1 (26593): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 157 veces - 0x00 -> 77 veces - -Offset 0x067E2 (26594): - Valores distintos (3): 0x00, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x7F -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x067E3 (26595): - Valores distintos (4): 0x00, 0xBC, 0xFC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFC -> 123 veces - 0x00 -> 77 veces - 0xBC -> 25 veces - 0xFF -> 9 veces - -Offset 0x067E4 (26596): - Valores distintos (4): 0x00, 0x02, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 123 veces - 0x00 -> 77 veces - 0x02 -> 25 veces - 0xFF -> 9 veces - -Offset 0x067E5 (26597): - Valores distintos (3): 0x00, 0x17, 0xFF - Clasificación: small_state - Más frecuentes: - 0x17 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x067E6 (26598): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067E7 (26599): - Valores distintos (5): 0x00, 0x38, 0xB8, 0xF8, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF8 -> 120 veces - 0x00 -> 77 veces - 0x38 -> 25 veces - 0xFF -> 9 veces - 0xB8 -> 3 veces - -Offset 0x067E8 (26600): - Valores distintos (3): 0x00, 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xDF -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x067E9 (26601): - Valores distintos (3): 0x00, 0x1B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1B -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x067EA (26602): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067EB (26603): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067EC (26604): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067ED (26605): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067EE (26606): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067EF (26607): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067F0 (26608): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 132 veces - 0x00 -> 102 veces - -Offset 0x067F1 (26609): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 132 veces - 0x00 -> 102 veces - -Offset 0x067F2 (26610): - Valores distintos (3): 0x00, 0x7B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x7B -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x067F3 (26611): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x067F4 (26612): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067F5 (26613): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067F6 (26614): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067F7 (26615): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x067F8 (26616): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 132 veces - 0x00 -> 102 veces - -Offset 0x067F9 (26617): - Valores distintos (3): 0x00, 0xF9, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF9 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x067FA (26618): - Valores distintos (4): 0x00, 0x09, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEF -> 120 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - 0x09 -> 3 veces - -Offset 0x067FB (26619): - Valores distintos (3): 0x00, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x7F -> 120 veces - 0x00 -> 105 veces - 0xFF -> 9 veces - -Offset 0x067FC (26620): - Valores distintos (5): 0x00, 0xC0, 0xCC, 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0xCC -> 72 veces - 0xDF -> 48 veces - 0xFF -> 9 veces - 0xC0 -> 3 veces - -Offset 0x067FD (26621): - Valores distintos (3): 0x00, 0xD0, 0xFF - Clasificación: small_state - Más frecuentes: - 0xD0 -> 120 veces - 0x00 -> 105 veces - 0xFF -> 9 veces - -Offset 0x067FE (26622): - Valores distintos (3): 0x00, 0xD7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xD7 -> 120 veces - 0x00 -> 105 veces - 0xFF -> 9 veces - -Offset 0x067FF (26623): - Valores distintos (5): 0x00, 0x60, 0x67, 0xE7, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x67 -> 72 veces - 0xE7 -> 48 veces - 0xFF -> 9 veces - 0x60 -> 3 veces - -Offset 0x06800 (26624): - Valores distintos (3): 0x00, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xF7 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06801 (26625): - Valores distintos (3): 0x00, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xEF -> 48 veces - 0xFF -> 9 veces - -Offset 0x06802 (26626): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x06803 (26627): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x07 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06804 (26628): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x06805 (26629): - Valores distintos (3): 0x00, 0xDB, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xDB -> 48 veces - 0xFF -> 9 veces - -Offset 0x06806 (26630): - Valores distintos (3): 0x00, 0xF0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xF0 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06807 (26631): - Valores distintos (3): 0x00, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3F -> 48 veces - 0xFF -> 9 veces - -Offset 0x06808 (26632): - Valores distintos (3): 0x00, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xF7 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06809 (26633): - Valores distintos (4): 0x00, 0x01, 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0xDF -> 48 veces - 0xFF -> 9 veces - -Offset 0x0680A (26634): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0F -> 48 veces - 0xFF -> 9 veces - -Offset 0x0680B (26635): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0680C (26636): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0680D (26637): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0680E (26638): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0680F (26639): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06810 (26640): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x07 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06811 (26641): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06812 (26642): - Valores distintos (3): 0x00, 0xF0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xF0 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06813 (26643): - Valores distintos (3): 0x00, 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x43 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06814 (26644): - Valores distintos (3): 0x00, 0xF0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xF0 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06815 (26645): - Valores distintos (3): 0x00, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xBF -> 48 veces - 0xFF -> 9 veces - -Offset 0x06816 (26646): - Valores distintos (3): 0x00, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x41 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06817 (26647): - Valores distintos (3): 0x00, 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x80 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06818 (26648): - Valores distintos (3): 0x00, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFD -> 48 veces - 0xFF -> 9 veces - -Offset 0x06819 (26649): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0681A (26650): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0681B (26651): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0681C (26652): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0681D (26653): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0681E (26654): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0681F (26655): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06820 (26656): - Valores distintos (4): 0x00, 0x01, 0xD1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0xD1 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06821 (26657): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xFF -> 30 veces - -Offset 0x06822 (26658): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xFF -> 30 veces - -Offset 0x06823 (26659): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xFF -> 21 veces - 0x01 -> 9 veces - -Offset 0x06824 (26660): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06825 (26661): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06826 (26662): - Valores distintos (4): 0x00, 0x20, 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x23 -> 12 veces - 0xFF -> 9 veces - 0x20 -> 9 veces - -Offset 0x06827 (26663): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06828 (26664): - Valores distintos (3): 0x00, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x7F -> 12 veces - 0xFF -> 9 veces - -Offset 0x06829 (26665): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0682A (26666): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0682B (26667): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0682C (26668): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0xFF -> 21 veces - -Offset 0x0682D (26669): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0xFF -> 21 veces - -Offset 0x0682E (26670): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0682F (26671): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06830 (26672): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06831 (26673): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06832 (26674): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06833 (26675): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06834 (26676): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06835 (26677): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06836 (26678): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06837 (26679): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06838 (26680): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06839 (26681): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0683A (26682): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0683B (26683): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0683C (26684): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0683D (26685): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0683E (26686): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0683F (26687): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06840 (26688): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06841 (26689): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06842 (26690): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06843 (26691): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06844 (26692): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06845 (26693): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06846 (26694): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06847 (26695): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06848 (26696): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06849 (26697): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0684A (26698): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0684B (26699): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0684C (26700): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0684D (26701): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0684E (26702): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0684F (26703): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06850 (26704): - Valores distintos (3): 0x08, 0xF8, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF8 -> 123 veces - 0x08 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06851 (26705): - Valores distintos (4): 0x00, 0x20, 0xE0, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE0 -> 123 veces - 0x00 -> 52 veces - 0x20 -> 50 veces - 0xFF -> 9 veces - -Offset 0x06852 (26706): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06853 (26707): - Valores distintos (3): 0x0A, 0x2F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2F -> 123 veces - 0x0A -> 102 veces - 0xFF -> 9 veces - -Offset 0x06854 (26708): - Valores distintos (3): 0x00, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06855 (26709): - Valores distintos (4): 0x00, 0x80, 0xE6, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x80 -> 75 veces - 0xE6 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06856 (26710): - Valores distintos (6): 0x00, 0x42, 0x4A, 0xDE, 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x4A -> 72 veces - 0xEE -> 27 veces - 0xDE -> 21 veces - 0xFF -> 9 veces - -Offset 0x06857 (26711): - Valores distintos (3): 0x00, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFD -> 48 veces - 0xFF -> 9 veces - -Offset 0x06858 (26712): - Valores distintos (5): 0x00, 0x08, 0x29, 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x29 -> 99 veces - 0xB9 -> 21 veces - 0xFF -> 9 veces - 0x08 -> 3 veces - -Offset 0x06859 (26713): - Valores distintos (4): 0x00, 0x20, 0x2A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x20 -> 27 veces - 0x2A -> 21 veces - 0xFF -> 9 veces - -Offset 0x0685A (26714): - Valores distintos (3): 0x00, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x11 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0685B (26715): - Valores distintos (4): 0x00, 0x18, 0x1E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x18 -> 27 veces - 0x1E -> 21 veces - 0xFF -> 9 veces - -Offset 0x0685C (26716): - Valores distintos (4): 0x00, 0x3F, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3F -> 27 veces - 0xBF -> 21 veces - 0xFF -> 9 veces - -Offset 0x0685D (26717): - Valores distintos (4): 0x00, 0xE9, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xE9 -> 27 veces - 0xFD -> 21 veces - 0xFF -> 9 veces - -Offset 0x0685E (26718): - Valores distintos (5): 0x00, 0x04, 0x07, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x04 -> 72 veces - 0x07 -> 27 veces - 0x0F -> 21 veces - 0xFF -> 9 veces - -Offset 0x0685F (26719): - Valores distintos (5): 0x00, 0x80, 0xC2, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x80 -> 102 veces - 0xFE -> 12 veces - 0xFF -> 9 veces - 0xC2 -> 9 veces - -Offset 0x06860 (26720): - Valores distintos (5): 0x00, 0x18, 0x1C, 0xDD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x18 -> 72 veces - 0x1C -> 36 veces - 0xDD -> 12 veces - 0xFF -> 9 veces - -Offset 0x06861 (26721): - Valores distintos (3): 0x00, 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x80 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06862 (26722): - Valores distintos (5): 0x00, 0x38, 0x3B, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x38 -> 27 veces - 0x3F -> 12 veces - 0xFF -> 9 veces - 0x3B -> 9 veces - -Offset 0x06863 (26723): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06864 (26724): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06865 (26725): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06866 (26726): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06867 (26727): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06868 (26728): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06869 (26729): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0686A (26730): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0686B (26731): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0686C (26732): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0686D (26733): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0686E (26734): - Valores distintos (3): 0x00, 0xE0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xE0 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0686F (26735): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 30 veces - 0x0F -> 27 veces - -Offset 0x06870 (26736): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06871 (26737): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06872 (26738): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06873 (26739): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06874 (26740): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06875 (26741): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06876 (26742): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06877 (26743): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06878 (26744): - Valores distintos (16): 0x1A, 0x27, 0x44, 0x45, 0x4B, 0x53, 0x5C, 0x63, 0x66, 0x81, 0x9E, 0xD2, 0xDF, 0xE1, 0xEB, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x4B -> 72 veces - 0xE1 -> 27 veces - 0x45 -> 25 veces - 0x5C -> 20 veces - 0x27 -> 20 veces - -Offset 0x06879 (26745): - Valores distintos (15): 0x00, 0x01, 0x03, 0x04, 0x05, 0x06, 0x0C, 0x13, 0x21, 0x2A, 0x3C, 0x5C, 0x65, 0xA4, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x3C -> 72 veces - 0x5C -> 27 veces - 0x06 -> 25 veces - 0x04 -> 20 veces - 0x05 -> 20 veces - -Offset 0x0687A (26746): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0687B (26747): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0687C (26748): - Valores distintos (3): 0x00, 0xE0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0xE0 -> 27 veces - 0xFF -> 9 veces - -Offset 0x0687D (26749): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x01 -> 27 veces - 0xFF -> 9 veces - -Offset 0x0687E (26750): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x09 -> 27 veces - 0xFF -> 9 veces - -Offset 0x0687F (26751): - Valores distintos (3): 0x00, 0xF0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xF0 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06880 (26752): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 206 veces - 0x01 -> 19 veces - 0xFF -> 9 veces - -Offset 0x06881 (26753): - Valores distintos (3): 0x07, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 177 veces - 0x3F -> 48 veces - 0xFF -> 9 veces - -Offset 0x06882 (26754): - Valores distintos (5): 0x00, 0x01, 0x05, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 120 veces - 0x00 -> 77 veces - 0x01 -> 25 veces - 0xFF -> 9 veces - 0x05 -> 3 veces - -Offset 0x06883 (26755): - Valores distintos (7): 0x00, 0x01, 0x03, 0x04, 0x05, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 112 veces - 0xFF -> 39 veces - 0x01 -> 39 veces - 0x00 -> 25 veces - 0x03 -> 8 veces - -Offset 0x06884 (26756): - Valores distintos (6): 0x01, 0x03, 0x04, 0x05, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 141 veces - 0xFF -> 69 veces - 0x08 -> 12 veces - 0x01 -> 8 veces - 0x04 -> 3 veces - -Offset 0x06885 (26757): - Valores distintos (5): 0x00, 0x03, 0x04, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 96 veces - 0x04 -> 72 veces - 0x07 -> 51 veces - 0xFF -> 9 veces - 0x03 -> 6 veces - -Offset 0x06886 (26758): - Valores distintos (7): 0x00, 0x01, 0x03, 0x04, 0x05, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 105 veces - 0xFF -> 39 veces - 0x01 -> 39 veces - 0x04 -> 30 veces - 0x08 -> 12 veces - -Offset 0x06887 (26759): - Valores distintos (5): 0x01, 0x04, 0x05, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 72 veces - 0xFF -> 69 veces - 0x05 -> 47 veces - 0x01 -> 33 veces - 0x04 -> 13 veces - -Offset 0x06888 (26760): - Valores distintos (6): 0x24, 0xA4, 0xAC, 0xEC, 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEC -> 100 veces - 0xEE -> 48 veces - 0xA4 -> 42 veces - 0xAC -> 25 veces - 0x24 -> 10 veces - -Offset 0x06889 (26761): - Valores distintos (5): 0x0C, 0x4E, 0xCE, 0xCF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xCF -> 148 veces - 0x4E -> 47 veces - 0xCE -> 25 veces - 0xFF -> 9 veces - 0x0C -> 5 veces - -Offset 0x0688A (26762): - Valores distintos (8): 0x80, 0xA0, 0xA2, 0xAA, 0xAE, 0xBE, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBF -> 123 veces - 0xBE -> 50 veces - 0xAE -> 22 veces - 0xAA -> 20 veces - 0xFF -> 9 veces - -Offset 0x0688B (26763): - Valores distintos (3): 0x67, 0xE7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE7 -> 195 veces - 0x67 -> 30 veces - 0xFF -> 9 veces - -Offset 0x0688C (26764): - Valores distintos (6): 0x00, 0x20, 0xE0, 0xE6, 0xEE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE6 -> 125 veces - 0xE0 -> 44 veces - 0xFF -> 30 veces - 0xEE -> 27 veces - 0x00 -> 5 veces - -Offset 0x0688D (26765): - Valores distintos (7): 0x00, 0x80, 0x83, 0x93, 0xB3, 0xF3, 0xFF - Clasificación: small_state - Más frecuentes: - 0x93 -> 125 veces - 0x83 -> 44 veces - 0xB3 -> 27 veces - 0xF3 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0688E (26766): - Valores distintos (4): 0x04, 0x2D, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2D -> 97 veces - 0x3F -> 75 veces - 0xFF -> 57 veces - 0x04 -> 5 veces - -Offset 0x0688F (26767): - Valores distintos (7): 0x00, 0x60, 0x63, 0xE3, 0xF3, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF3 -> 75 veces - 0x60 -> 47 veces - 0xF7 -> 36 veces - 0x63 -> 25 veces - 0xE3 -> 25 veces - -Offset 0x06890 (26768): - Valores distintos (6): 0x00, 0x02, 0x82, 0x92, 0xF2, 0xFF - Clasificación: small_state - Más frecuentes: - 0x92 -> 102 veces - 0x00 -> 52 veces - 0x02 -> 25 veces - 0x82 -> 25 veces - 0xF2 -> 21 veces - -Offset 0x06891 (26769): - Valores distintos (3): 0x00, 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x78 -> 165 veces - 0x00 -> 60 veces - 0xFF -> 9 veces - -Offset 0x06892 (26770): - Valores distintos (6): 0x00, 0x03, 0x07, 0xE7, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE7 -> 127 veces - 0x00 -> 30 veces - 0x07 -> 25 veces - 0x03 -> 22 veces - 0xEF -> 21 veces - -Offset 0x06893 (26771): - Valores distintos (5): 0x00, 0x10, 0x16, 0x7E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x7E -> 123 veces - 0x00 -> 52 veces - 0x10 -> 25 veces - 0x16 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06894 (26772): - Valores distintos (3): 0x00, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0xFE -> 75 veces - 0xFF -> 57 veces - -Offset 0x06895 (26773): - Valores distintos (5): 0x00, 0x01, 0xED, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0xED -> 75 veces - 0x00 -> 52 veces - 0x01 -> 50 veces - 0xFD -> 48 veces - 0xFF -> 9 veces - -Offset 0x06896 (26774): - Valores distintos (4): 0x00, 0x04, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x14 -> 75 veces - 0xFF -> 57 veces - 0x00 -> 52 veces - 0x04 -> 50 veces - -Offset 0x06897 (26775): - Valores distintos (4): 0x00, 0xA0, 0xA9, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xA0 -> 27 veces - 0xA9 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06898 (26776): - Valores distintos (4): 0x00, 0xB7, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xB7 -> 36 veces - 0xF7 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06899 (26777): - Valores distintos (4): 0x00, 0x38, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x38 -> 27 veces - 0xFF -> 21 veces - 0x7F -> 9 veces - -Offset 0x0689A (26778): - Valores distintos (5): 0x00, 0x5D, 0x5F, 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x5D -> 27 veces - 0xDF -> 12 veces - 0xFF -> 9 veces - 0x5F -> 9 veces - -Offset 0x0689B (26779): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0xFF -> 21 veces - -Offset 0x0689C (26780): - Valores distintos (5): 0x00, 0x10, 0x38, 0xF8, 0xFF - Clasificación: small_state - Más frecuentes: - 0x38 -> 102 veces - 0x00 -> 52 veces - 0x10 -> 50 veces - 0xFF -> 21 veces - 0xF8 -> 9 veces - -Offset 0x0689D (26781): - Valores distintos (5): 0x00, 0x08, 0xE8, 0xEC, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 125 veces - 0x00 -> 52 veces - 0xE8 -> 27 veces - 0xFF -> 21 veces - 0xEC -> 9 veces - -Offset 0x0689E (26782): - Valores distintos (5): 0x00, 0x03, 0x0F, 0x2F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x03 -> 72 veces - 0x0F -> 36 veces - 0x2F -> 12 veces - 0xFF -> 9 veces - -Offset 0x0689F (26783): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A0 (26784): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A1 (26785): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A2 (26786): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A3 (26787): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A4 (26788): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A5 (26789): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A6 (26790): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A7 (26791): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068A8 (26792): - Valores distintos (4): 0x00, 0x08, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 127 veces - 0x00 -> 77 veces - 0x48 -> 21 veces - 0xFF -> 9 veces - -Offset 0x068A9 (26793): - Valores distintos (4): 0x00, 0x04, 0x84, 0xFF - Clasificación: small_state - Más frecuentes: - 0x84 -> 123 veces - 0x00 -> 77 veces - 0x04 -> 25 veces - 0xFF -> 9 veces - -Offset 0x068AA (26794): - Valores distintos (6): 0x00, 0x10, 0x50, 0x58, 0x59, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 100 veces - 0x00 -> 77 veces - 0x50 -> 27 veces - 0x59 -> 12 veces - 0xFF -> 9 veces - -Offset 0x068AB (26795): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x068AC (26796): - Valores distintos (5): 0x00, 0x80, 0x90, 0xD0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x90 -> 152 veces - 0x00 -> 30 veces - 0x80 -> 22 veces - 0xD0 -> 21 veces - 0xFF -> 9 veces - -Offset 0x068AD (26797): - Valores distintos (4): 0x00, 0x04, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x0F -> 21 veces - 0xFF -> 9 veces - -Offset 0x068AE (26798): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068AF (26799): - Valores distintos (4): 0x00, 0x04, 0xC4, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 152 veces - 0x00 -> 52 veces - 0xC4 -> 21 veces - 0xFF -> 9 veces - -Offset 0x068B0 (26800): - Valores distintos (3): 0x00, 0x20, 0xFF - Clasificación: small_state - Más frecuentes: - 0x20 -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x068B1 (26801): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068B2 (26802): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068B3 (26803): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068B4 (26804): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068B5 (26805): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068B6 (26806): - Valores distintos (3): 0x00, 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 195 veces - 0x00 -> 30 veces - 0xFF -> 9 veces - -Offset 0x068B7 (26807): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068B8 (26808): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068B9 (26809): - Valores distintos (3): 0x00, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x10 -> 21 veces - 0xFF -> 9 veces - -Offset 0x068BA (26810): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068BB (26811): - Valores distintos (4): 0x00, 0x02, 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x02 -> 102 veces - 0x76 -> 21 veces - 0xFF -> 9 veces - -Offset 0x068BC (26812): - Valores distintos (5): 0x00, 0x30, 0x70, 0x78, 0xFF - Clasificación: small_state - Más frecuentes: - 0x30 -> 100 veces - 0x00 -> 77 veces - 0x70 -> 27 veces - 0x78 -> 21 veces - 0xFF -> 9 veces - -Offset 0x068BD (26813): - Valores distintos (5): 0x00, 0x04, 0x26, 0x3E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 147 veces - 0x00 -> 30 veces - 0x26 -> 27 veces - 0x3E -> 21 veces - 0xFF -> 9 veces - -Offset 0x068BE (26814): - Valores distintos (3): 0x00, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x08 -> 48 veces - 0xFF -> 9 veces - -Offset 0x068BF (26815): - Valores distintos (4): 0x00, 0x02, 0x12, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 125 veces - 0x00 -> 52 veces - 0x12 -> 48 veces - 0xFF -> 9 veces - -Offset 0x068C0 (26816): - Valores distintos (4): 0x00, 0x48, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x48 -> 27 veces - 0x58 -> 21 veces - 0xFF -> 9 veces - -Offset 0x068C1 (26817): - Valores distintos (4): 0x00, 0x80, 0xCA, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x80 -> 27 veces - 0xCA -> 21 veces - 0xFF -> 9 veces - -Offset 0x068C2 (26818): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068C3 (26819): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x068C4 (26820): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068C5 (26821): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068C6 (26822): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068C7 (26823): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068C8 (26824): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068C9 (26825): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068CA (26826): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068CB (26827): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068CC (26828): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068CD (26829): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068CE (26830): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068CF (26831): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D0 (26832): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D1 (26833): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D2 (26834): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D3 (26835): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D4 (26836): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D5 (26837): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D6 (26838): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D7 (26839): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D8 (26840): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068D9 (26841): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068DA (26842): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068DB (26843): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068DC (26844): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068DD (26845): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068DE (26846): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068DF (26847): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E0 (26848): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E1 (26849): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E2 (26850): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E3 (26851): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E4 (26852): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E5 (26853): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E6 (26854): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E7 (26855): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068E8 (26856): - Valores distintos (15): 0x01, 0x03, 0x04, 0x05, 0x07, 0x08, 0x0B, 0x0D, 0x12, 0x1A, 0x1B, 0x2F, 0x42, 0x45, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 72 veces - 0x2F -> 27 veces - 0x12 -> 25 veces - 0x08 -> 21 veces - 0x05 -> 20 veces - -Offset 0x068E9 (26857): - Valores distintos (17): 0x03, 0x0C, 0x0F, 0x19, 0x1C, 0x1E, 0x1F, 0x26, 0x27, 0x28, 0x2B, 0x30, 0x31, 0x34, 0x3A, 0x3B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x2B -> 71 veces - 0x30 -> 32 veces - 0x3A -> 25 veces - 0x03 -> 20 veces - 0x19 -> 20 veces - -Offset 0x068EA (26858): - Valores distintos (17): 0x05, 0x07, 0x09, 0x0B, 0x12, 0x16, 0x1B, 0x1F, 0x22, 0x25, 0x26, 0x27, 0x2B, 0x31, 0x34, 0x36, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 71 veces - 0x1F -> 37 veces - 0x25 -> 27 veces - 0x16 -> 25 veces - 0x1B -> 20 veces - -Offset 0x068EB (26859): - Valores distintos (14): 0x01, 0x03, 0x04, 0x07, 0x09, 0x0A, 0x0B, 0x11, 0x14, 0x19, 0x1A, 0x1B, 0x1C, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1A -> 71 veces - 0x11 -> 31 veces - 0x09 -> 25 veces - 0x19 -> 20 veces - 0x03 -> 20 veces - -Offset 0x068EC (26860): - Valores distintos (2): 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 225 veces - 0xFF -> 9 veces - -Offset 0x068ED (26861): - Valores distintos (4): 0x20, 0x7E, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFE -> 123 veces - 0x7E -> 97 veces - 0xFF -> 9 veces - 0x20 -> 5 veces - -Offset 0x068EE (26862): - Valores distintos (5): 0x00, 0x08, 0xF8, 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFB -> 123 veces - 0xF8 -> 72 veces - 0x08 -> 20 veces - 0x00 -> 10 veces - 0xFF -> 9 veces - -Offset 0x068EF (26863): - Valores distintos (6): 0x00, 0x80, 0x81, 0x8D, 0x8F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x8D -> 125 veces - 0x8F -> 48 veces - 0x80 -> 22 veces - 0x81 -> 22 veces - 0xFF -> 9 veces - -Offset 0x068F0 (26864): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 182 veces - 0x01 -> 44 veces - 0x00 -> 8 veces - -Offset 0x068F1 (26865): - Valores distintos (5): 0x00, 0x07, 0x77, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0x77 -> 102 veces - 0x00 -> 52 veces - 0x07 -> 50 veces - 0xF7 -> 21 veces - 0xFF -> 9 veces - -Offset 0x068F2 (26866): - Valores distintos (3): 0x00, 0xFC, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0xFC -> 75 veces - 0xFF -> 57 veces - -Offset 0x068F3 (26867): - Valores distintos (4): 0x00, 0x40, 0xF7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xF7 -> 123 veces - 0x00 -> 52 veces - 0x40 -> 50 veces - 0xFF -> 9 veces - -Offset 0x068F4 (26868): - Valores distintos (5): 0x00, 0x08, 0x0F, 0x8F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 75 veces - 0x08 -> 71 veces - 0x8F -> 48 veces - 0x00 -> 31 veces - 0xFF -> 9 veces - -Offset 0x068F5 (26869): - Valores distintos (3): 0x00, 0xDF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0xDF -> 75 veces - 0xFF -> 57 veces - -Offset 0x068F6 (26870): - Valores distintos (5): 0x00, 0x07, 0x0F, 0x7F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x0F -> 72 veces - 0x7F -> 48 veces - 0xFF -> 9 veces - 0x07 -> 3 veces - -Offset 0x068F7 (26871): - Valores distintos (4): 0x00, 0x60, 0x68, 0xFF - Clasificación: small_state - Más frecuentes: - 0x60 -> 100 veces - 0x00 -> 77 veces - 0x68 -> 48 veces - 0xFF -> 9 veces - -Offset 0x068F8 (26872): - Valores distintos (6): 0x00, 0x01, 0x03, 0xEB, 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 75 veces - 0x00 -> 52 veces - 0x01 -> 50 veces - 0xEB -> 36 veces - 0xFB -> 12 veces - -Offset 0x068F9 (26873): - Valores distintos (3): 0x00, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFD -> 48 veces - 0xFF -> 9 veces - -Offset 0x068FA (26874): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x068FB (26875): - Valores distintos (4): 0x00, 0x1F, 0x9F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x1F -> 27 veces - 0x9F -> 21 veces - 0xFF -> 9 veces - -Offset 0x068FC (26876): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xFF -> 30 veces - -Offset 0x068FD (26877): - Valores distintos (4): 0x00, 0x03, 0xBB, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xBB -> 12 veces - 0xFF -> 9 veces - 0x03 -> 9 veces - -Offset 0x068FE (26878): - Valores distintos (4): 0x00, 0x08, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 120 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - 0x08 -> 3 veces - -Offset 0x068FF (26879): - Valores distintos (5): 0x00, 0x20, 0x3E, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x20 -> 75 veces - 0x3E -> 27 veces - 0xFE -> 21 veces - 0xFF -> 9 veces - -Offset 0x06900 (26880): - Valores distintos (6): 0x00, 0x20, 0xA0, 0xA6, 0xA7, 0xFF - Clasificación: small_state - Más frecuentes: - 0xA0 -> 167 veces - 0xA6 -> 27 veces - 0xA7 -> 21 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x06901 (26881): - Valores distintos (4): 0x00, 0x10, 0x34, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x10 -> 75 veces - 0x34 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06902 (26882): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06903 (26883): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06904 (26884): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06905 (26885): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06906 (26886): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06907 (26887): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06908 (26888): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06909 (26889): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0690A (26890): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0690B (26891): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0690C (26892): - Valores distintos (3): 0x00, 0x1B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1B -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x0690D (26893): - Valores distintos (4): 0x00, 0x26, 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x27 -> 148 veces - 0x26 -> 72 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x0690E (26894): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0690F (26895): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06910 (26896): - Valores distintos (3): 0x00, 0x3B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3B -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06911 (26897): - Valores distintos (3): 0x00, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x28 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06912 (26898): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06913 (26899): - Valores distintos (3): 0x00, 0x42, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x42 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06914 (26900): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06915 (26901): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06916 (26902): - Valores distintos (3): 0x00, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1F -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06917 (26903): - Valores distintos (3): 0x00, 0x12, 0xFF - Clasificación: small_state - Más frecuentes: - 0x12 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06918 (26904): - Valores distintos (3): 0x00, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06919 (26905): - Valores distintos (3): 0x00, 0x18, 0xFF - Clasificación: small_state - Más frecuentes: - 0x18 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x0691A (26906): - Valores distintos (4): 0x00, 0x23, 0x38, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 127 veces - 0x00 -> 77 veces - 0x38 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0691B (26907): - Valores distintos (4): 0x00, 0x34, 0x37, 0xFF - Clasificación: small_state - Más frecuentes: - 0x37 -> 123 veces - 0x00 -> 77 veces - 0x34 -> 25 veces - 0xFF -> 9 veces - -Offset 0x0691C (26908): - Valores distintos (4): 0x00, 0x26, 0x44, 0xFF - Clasificación: small_state - Más frecuentes: - 0x26 -> 127 veces - 0x00 -> 77 veces - 0x44 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0691D (26909): - Valores distintos (3): 0x00, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x54 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0691E (26910): - Valores distintos (3): 0x00, 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x4B -> 21 veces - 0xFF -> 9 veces - -Offset 0x0691F (26911): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06920 (26912): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06921 (26913): - Valores distintos (3): 0x00, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x41 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06922 (26914): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06923 (26915): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06924 (26916): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06925 (26917): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06926 (26918): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06927 (26919): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06928 (26920): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06929 (26921): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0692A (26922): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0692B (26923): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0692C (26924): - Valores distintos (4): 0x70, 0x7C, 0x7E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x7C -> 195 veces - 0x7E -> 21 veces - 0xFF -> 9 veces - 0x70 -> 9 veces - -Offset 0x0692D (26925): - Valores distintos (3): 0x01, 0x85, 0xFF - Clasificación: small_state - Más frecuentes: - 0x85 -> 217 veces - 0xFF -> 9 veces - 0x01 -> 8 veces - -Offset 0x0692E (26926): - Valores distintos (4): 0x00, 0x04, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 217 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0x04 -> 3 veces - -Offset 0x0692F (26927): - Valores distintos (4): 0x00, 0xC0, 0xE0, 0xFF - Clasificación: small_state - Más frecuentes: - 0xE0 -> 123 veces - 0x00 -> 77 veces - 0xC0 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06930 (26928): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 157 veces - 0x00 -> 77 veces - -Offset 0x06931 (26929): - Valores distintos (3): 0x00, 0x3F, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 132 veces - 0x00 -> 77 veces - 0x3F -> 25 veces - -Offset 0x06932 (26930): - Valores distintos (3): 0x00, 0xCC, 0xFF - Clasificación: small_state - Más frecuentes: - 0xCC -> 173 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x06933 (26931): - Valores distintos (5): 0x00, 0x04, 0x07, 0x4F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x4F -> 148 veces - 0x00 -> 32 veces - 0x07 -> 25 veces - 0x04 -> 20 veces - 0xFF -> 9 veces - -Offset 0x06934 (26932): - Valores distintos (7): 0x00, 0x20, 0xE0, 0xE8, 0xEE, 0xFE, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEE -> 75 veces - 0xFE -> 48 veces - 0x00 -> 32 veces - 0x20 -> 28 veces - 0xE8 -> 25 veces - -Offset 0x06935 (26933): - Valores distintos (6): 0x00, 0x02, 0x03, 0x13, 0x3B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3B -> 120 veces - 0x00 -> 60 veces - 0x03 -> 25 veces - 0x02 -> 17 veces - 0xFF -> 9 veces - -Offset 0x06936 (26934): - Valores distintos (6): 0x00, 0x04, 0x14, 0x1C, 0xDE, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1C -> 75 veces - 0x00 -> 52 veces - 0xDE -> 48 veces - 0x04 -> 25 veces - 0x14 -> 25 veces - -Offset 0x06937 (26935): - Valores distintos (4): 0x00, 0x03, 0xD7, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 27 veces - 0xD7 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06938 (26936): - Valores distintos (5): 0x00, 0x80, 0xC0, 0xFD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 125 veces - 0x00 -> 52 veces - 0xC0 -> 27 veces - 0xFD -> 21 veces - 0xFF -> 9 veces - -Offset 0x06939 (26937): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0693A (26938): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0693B (26939): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0693C (26940): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0693D (26941): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0693E (26942): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0693F (26943): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06940 (26944): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06941 (26945): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06942 (26946): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06943 (26947): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06944 (26948): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06945 (26949): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06946 (26950): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06947 (26951): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06948 (26952): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06949 (26953): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0694A (26954): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0694B (26955): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0694C (26956): - Valores distintos (6): 0x80, 0x81, 0x85, 0x8D, 0x8F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x8D -> 102 veces - 0x81 -> 50 veces - 0x85 -> 30 veces - 0x80 -> 22 veces - 0x8F -> 21 veces - -Offset 0x0694D (26957): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0694E (26958): - Valores distintos (6): 0x00, 0x1C, 0x1D, 0x1E, 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 75 veces - 0x1C -> 72 veces - 0x1D -> 52 veces - 0x1E -> 21 veces - 0xFF -> 9 veces - -Offset 0x0694F (26959): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x06950 (26960): - Valores distintos (6): 0x00, 0x2E, 0x2F, 0x31, 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2F -> 100 veces - 0x2E -> 72 veces - 0x32 -> 27 veces - 0x31 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06951 (26961): - Valores distintos (11): 0x07, 0x21, 0x2D, 0x34, 0x4A, 0x4D, 0x50, 0x61, 0x6F, 0x95, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x4D -> 124 veces - 0x34 -> 28 veces - 0x95 -> 27 veces - 0x4A -> 17 veces - 0x6F -> 12 veces - -Offset 0x06952 (26962): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06953 (26963): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06954 (26964): - Valores distintos (17): 0x32, 0x3E, 0x4E, 0x60, 0x64, 0x75, 0x7A, 0x80, 0x88, 0x94, 0xA3, 0xAD, 0xDC, 0xDE, 0xE1, 0xE2, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xAD -> 72 veces - 0xA3 -> 27 veces - 0xDC -> 25 veces - 0x88 -> 20 veces - 0xE2 -> 20 veces - -Offset 0x06955 (26965): - Valores distintos (6): 0x00, 0x01, 0x02, 0x04, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 75 veces - 0x00 -> 52 veces - 0x01 -> 50 veces - 0x04 -> 27 veces - 0x07 -> 21 veces - -Offset 0x06956 (26966): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06957 (26967): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06958 (26968): - Valores distintos (17): 0x03, 0x10, 0x1E, 0x25, 0x34, 0x67, 0x6D, 0x7F, 0x81, 0x88, 0x8B, 0x91, 0xA6, 0xEC, 0xF5, 0xFB, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x25 -> 72 veces - 0x03 -> 27 veces - 0x67 -> 25 veces - 0x81 -> 20 veces - 0x6D -> 20 veces - -Offset 0x06959 (26969): - Valores distintos (15): 0x03, 0x07, 0x09, 0x0A, 0x12, 0x13, 0x31, 0x38, 0x41, 0x4C, 0x80, 0xC2, 0xD4, 0xDD, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xD4 -> 72 veces - 0xDD -> 27 veces - 0x4C -> 25 veces - 0x0A -> 21 veces - 0x13 -> 20 veces - -Offset 0x0695A (26970): - Valores distintos (4): 0x00, 0x02, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0695B (26971): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0695C (26972): - Valores distintos (13): 0x04, 0x05, 0x0A, 0x0C, 0x0E, 0x16, 0x19, 0x2E, 0x35, 0x37, 0x3F, 0x49, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x37 -> 72 veces - 0x3F -> 27 veces - 0x2E -> 25 veces - 0x0C -> 23 veces - 0x49 -> 21 veces - -Offset 0x0695D (26973): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0695E (26974): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0695F (26975): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06960 (26976): - Valores distintos (15): 0x03, 0x0B, 0x0D, 0x0F, 0x29, 0x2C, 0x46, 0x53, 0x57, 0x83, 0x85, 0xE5, 0xF6, 0xFB, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x85 -> 72 veces - 0xE5 -> 27 veces - 0x57 -> 25 veces - 0x2C -> 21 veces - 0x0F -> 20 veces - -Offset 0x06961 (26977): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06962 (26978): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06963 (26979): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06964 (26980): - Valores distintos (7): 0x00, 0x01, 0x07, 0x0A, 0x0E, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 75 veces - 0x01 -> 72 veces - 0x0E -> 27 veces - 0x07 -> 25 veces - 0x16 -> 21 veces - -Offset 0x06965 (26981): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06966 (26982): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06967 (26983): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06968 (26984): - Valores distintos (3): 0x00, 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x80 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06969 (26985): - Valores distintos (3): 0x00, 0x88, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x88 -> 27 veces - 0xFF -> 9 veces - -Offset 0x0696A (26986): - Valores distintos (14): 0x08, 0x12, 0x14, 0x1C, 0x1D, 0x21, 0x23, 0x26, 0x29, 0x2B, 0x31, 0x32, 0x37, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1D -> 71 veces - 0x08 -> 27 veces - 0x31 -> 25 veces - 0x29 -> 23 veces - 0x14 -> 21 veces - -Offset 0x0696B (26987): - Valores distintos (3): 0x00, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x15 -> 27 veces - 0xFF -> 9 veces - -Offset 0x0696C (26988): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0696D (26989): - Valores distintos (3): 0x00, 0xAD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0xAD -> 27 veces - 0xFF -> 9 veces - -Offset 0x0696E (26990): - Valores distintos (11): 0x13, 0x1E, 0x24, 0x25, 0x2A, 0x2C, 0x2D, 0x32, 0x38, 0x3B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x2C -> 71 veces - 0x25 -> 48 veces - 0x2D -> 25 veces - 0x24 -> 22 veces - 0x3B -> 21 veces - -Offset 0x0696F (26991): - Valores distintos (3): 0x00, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x10 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06970 (26992): - Valores distintos (7): 0x10, 0x21, 0x2D, 0x41, 0x57, 0xBD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 82 veces - 0x2D -> 60 veces - 0x57 -> 46 veces - 0xBD -> 27 veces - 0xFF -> 9 veces - -Offset 0x06971 (26993): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06972 (26994): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 151 veces - 0x00 -> 74 veces - 0xFF -> 9 veces - -Offset 0x06973 (26995): - Valores distintos (6): 0x00, 0x02, 0x03, 0x04, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x03 -> 71 veces - 0x04 -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06974 (26996): - Valores distintos (3): 0x04, 0x5B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 177 veces - 0x5B -> 48 veces - 0xFF -> 9 veces - -Offset 0x06975 (26997): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06976 (26998): - Valores distintos (2): 0x29, 0xFF - Clasificación: small_state - Más frecuentes: - 0x29 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06977 (26999): - Valores distintos (2): 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06978 (27000): - Valores distintos (2): 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0D -> 225 veces - 0xFF -> 9 veces - -Offset 0x06979 (27001): - Valores distintos (4): 0x0A, 0x22, 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 195 veces - 0x27 -> 20 veces - 0x22 -> 10 veces - 0xFF -> 9 veces - -Offset 0x0697A (27002): - Valores distintos (4): 0x06, 0x0A, 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 195 veces - 0x0A -> 20 veces - 0x27 -> 10 veces - 0xFF -> 9 veces - -Offset 0x0697B (27003): - Valores distintos (5): 0x00, 0x06, 0x0A, 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x39 -> 195 veces - 0x06 -> 20 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - 0x0A -> 5 veces - -Offset 0x0697C (27004): - Valores distintos (6): 0x00, 0x06, 0x1A, 0x27, 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1A -> 147 veces - 0x27 -> 48 veces - 0x39 -> 20 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x0697D (27005): - Valores distintos (7): 0x00, 0x05, 0x08, 0x1A, 0x27, 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x27 -> 100 veces - 0x08 -> 48 veces - 0x05 -> 47 veces - 0x1A -> 20 veces - 0xFF -> 9 veces - -Offset 0x0697E (27006): - Valores distintos (7): 0x00, 0x05, 0x08, 0x0B, 0x0F, 0x18, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 100 veces - 0x0F -> 48 veces - 0x00 -> 30 veces - 0x0B -> 22 veces - 0x05 -> 20 veces - -Offset 0x0697F (27007): - Valores distintos (6): 0x00, 0x0F, 0x15, 0x22, 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0F -> 125 veces - 0x43 -> 48 veces - 0x00 -> 25 veces - 0x22 -> 22 veces - 0xFF -> 9 veces - -Offset 0x06980 (27008): - Valores distintos (8): 0x00, 0x0B, 0x18, 0x1A, 0x22, 0x43, 0x44, 0xFF - Clasificación: small_state - Más frecuentes: - 0x43 -> 100 veces - 0x44 -> 48 veces - 0x0B -> 25 veces - 0x18 -> 22 veces - 0x22 -> 20 veces - -Offset 0x06981 (27009): - Valores distintos (8): 0x00, 0x05, 0x15, 0x18, 0x22, 0x3C, 0x44, 0xFF - Clasificación: small_state - Más frecuentes: - 0x44 -> 100 veces - 0x3C -> 48 veces - 0x22 -> 25 veces - 0x15 -> 22 veces - 0x18 -> 20 veces - -Offset 0x06982 (27010): - Valores distintos (8): 0x00, 0x15, 0x16, 0x18, 0x38, 0x3C, 0x47, 0xFF - Clasificación: small_state - Más frecuentes: - 0x3C -> 75 veces - 0x38 -> 48 veces - 0x18 -> 25 veces - 0x47 -> 25 veces - 0x16 -> 22 veces - -Offset 0x06983 (27011): - Valores distintos (8): 0x00, 0x02, 0x15, 0x16, 0x38, 0x3C, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x38 -> 75 veces - 0x02 -> 48 veces - 0x15 -> 25 veces - 0x3C -> 25 veces - 0x58 -> 22 veces - -Offset 0x06984 (27012): - Valores distintos (8): 0x00, 0x12, 0x16, 0x1F, 0x28, 0x38, 0x42, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1F -> 75 veces - 0x00 -> 30 veces - 0x28 -> 27 veces - 0x16 -> 25 veces - 0x38 -> 25 veces - -Offset 0x06985 (27013): - Valores distintos (8): 0x00, 0x02, 0x14, 0x1F, 0x42, 0x46, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 75 veces - 0x00 -> 31 veces - 0x42 -> 27 veces - 0x58 -> 25 veces - 0x1F -> 25 veces - -Offset 0x06986 (27014): - Valores distintos (7): 0x00, 0x02, 0x12, 0x28, 0x45, 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x28 -> 75 veces - 0x00 -> 52 veces - 0x46 -> 27 veces - 0x12 -> 25 veces - 0x02 -> 25 veces - -Offset 0x06987 (27015): - Valores distintos (7): 0x00, 0x05, 0x14, 0x19, 0x28, 0x45, 0xFF - Clasificación: small_state - Más frecuentes: - 0x19 -> 75 veces - 0x00 -> 52 veces - 0x45 -> 27 veces - 0x14 -> 25 veces - 0x28 -> 25 veces - -Offset 0x06988 (27016): - Valores distintos (7): 0x00, 0x05, 0x07, 0x19, 0x21, 0x42, 0xFF - Clasificación: small_state - Más frecuentes: - 0x42 -> 75 veces - 0x00 -> 52 veces - 0x05 -> 27 veces - 0x21 -> 25 veces - 0x19 -> 25 veces - -Offset 0x06989 (27017): - Valores distintos (6): 0x00, 0x07, 0x42, 0x46, 0x56, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x46 -> 75 veces - 0x07 -> 27 veces - 0x42 -> 25 veces - 0x56 -> 21 veces - -Offset 0x0698A (27018): - Valores distintos (6): 0x00, 0x09, 0x1D, 0x46, 0x56, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x1D -> 75 veces - 0x56 -> 27 veces - 0x46 -> 25 veces - 0x09 -> 21 veces - -Offset 0x0698B (27019): - Valores distintos (6): 0x00, 0x0B, 0x23, 0x3D, 0x57, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x57 -> 75 veces - 0x3D -> 27 veces - 0x0B -> 25 veces - 0x23 -> 21 veces - -Offset 0x0698C (27020): - Valores distintos (6): 0x00, 0x0B, 0x1A, 0x1C, 0x22, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x1C -> 75 veces - 0x0B -> 27 veces - 0x22 -> 25 veces - 0x1A -> 21 veces - -Offset 0x0698D (27021): - Valores distintos (5): 0x00, 0x18, 0x1F, 0x45, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x45 -> 75 veces - 0x18 -> 52 veces - 0x1F -> 21 veces - 0xFF -> 9 veces - -Offset 0x0698E (27022): - Valores distintos (5): 0x00, 0x05, 0x15, 0x19, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x05 -> 75 veces - 0x15 -> 52 veces - 0x19 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0698F (27023): - Valores distintos (5): 0x00, 0x07, 0x16, 0x1D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x07 -> 75 veces - 0x16 -> 52 veces - 0x1D -> 21 veces - 0xFF -> 9 veces - -Offset 0x06990 (27024): - Valores distintos (6): 0x00, 0x12, 0x56, 0x57, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x56 -> 75 veces - 0x12 -> 27 veces - 0x58 -> 25 veces - 0x57 -> 21 veces - -Offset 0x06991 (27025): - Valores distintos (6): 0x00, 0x12, 0x14, 0x1C, 0x3D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x3D -> 75 veces - 0x14 -> 27 veces - 0x12 -> 25 veces - 0x1C -> 21 veces - -Offset 0x06992 (27026): - Valores distintos (6): 0x00, 0x0B, 0x14, 0x1E, 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x0B -> 75 veces - 0x21 -> 27 veces - 0x14 -> 25 veces - 0x1E -> 21 veces - -Offset 0x06993 (27027): - Valores distintos (6): 0x00, 0x21, 0x22, 0x28, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x22 -> 75 veces - 0x48 -> 27 veces - 0x21 -> 25 veces - 0x28 -> 21 veces - -Offset 0x06994 (27028): - Valores distintos (6): 0x00, 0x0E, 0x18, 0x24, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x18 -> 75 veces - 0x0E -> 27 veces - 0x48 -> 25 veces - 0x24 -> 21 veces - -Offset 0x06995 (27029): - Valores distintos (6): 0x00, 0x0E, 0x15, 0x17, 0x1B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x15 -> 75 veces - 0x17 -> 27 veces - 0x0E -> 25 veces - 0x1B -> 21 veces - -Offset 0x06996 (27030): - Valores distintos (6): 0x00, 0x04, 0x16, 0x20, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x16 -> 75 veces - 0x20 -> 27 veces - 0x26 -> 25 veces - 0x04 -> 21 veces - -Offset 0x06997 (27031): - Valores distintos (5): 0x00, 0x09, 0x58, 0x5A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x58 -> 75 veces - 0x09 -> 27 veces - 0x5A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06998 (27032): - Valores distintos (5): 0x00, 0x12, 0x23, 0x2A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x12 -> 75 veces - 0x23 -> 27 veces - 0x2A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06999 (27033): - Valores distintos (5): 0x00, 0x14, 0x1A, 0x4A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x14 -> 75 veces - 0x1A -> 27 veces - 0x4A -> 21 veces - 0xFF -> 9 veces - -Offset 0x0699A (27034): - Valores distintos (5): 0x00, 0x1F, 0x21, 0x3D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x21 -> 75 veces - 0x1F -> 27 veces - 0x3D -> 21 veces - 0xFF -> 9 veces - -Offset 0x0699B (27035): - Valores distintos (5): 0x00, 0x0B, 0x19, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x48 -> 75 veces - 0x19 -> 27 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x0699C (27036): - Valores distintos (5): 0x00, 0x0E, 0x18, 0x1D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x0E -> 75 veces - 0x1D -> 27 veces - 0x18 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0699D (27037): - Valores distintos (5): 0x00, 0x15, 0x26, 0x57, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x26 -> 75 veces - 0x57 -> 27 veces - 0x15 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0699E (27038): - Valores distintos (5): 0x00, 0x16, 0x17, 0x1C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x17 -> 75 veces - 0x1C -> 27 veces - 0x16 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0699F (27039): - Valores distintos (5): 0x00, 0x12, 0x20, 0x22, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x20 -> 75 veces - 0x22 -> 27 veces - 0x12 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A0 (27040): - Valores distintos (5): 0x00, 0x14, 0x32, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x32 -> 75 veces - 0x58 -> 27 veces - 0x14 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A1 (27041): - Valores distintos (4): 0x00, 0x21, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x26 -> 27 veces - 0x21 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A2 (27042): - Valores distintos (4): 0x00, 0x32, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x32 -> 27 veces - 0x48 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A3 (27043): - Valores distintos (4): 0x00, 0x0E, 0x1E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x1E -> 27 veces - 0x0E -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A4 (27044): - Valores distintos (4): 0x00, 0x17, 0x59, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x59 -> 27 veces - 0x17 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A5 (27045): - Valores distintos (4): 0x00, 0x20, 0x4D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4D -> 27 veces - 0x20 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A6 (27046): - Valores distintos (4): 0x00, 0x22, 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x24 -> 27 veces - 0x22 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A7 (27047): - Valores distintos (4): 0x00, 0x1B, 0x58, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x1B -> 27 veces - 0x58 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A8 (27048): - Valores distintos (4): 0x00, 0x04, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069A9 (27049): - Valores distintos (3): 0x00, 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x32 -> 21 veces - 0xFF -> 9 veces - -Offset 0x069AA (27050): - Valores distintos (3): 0x00, 0x4D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x4D -> 21 veces - 0xFF -> 9 veces - -Offset 0x069AB (27051): - Valores distintos (3): 0x00, 0x37, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x37 -> 12 veces - 0xFF -> 9 veces - -Offset 0x069AC (27052): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069AD (27053): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069AE (27054): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069AF (27055): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B0 (27056): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B1 (27057): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B2 (27058): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B3 (27059): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B4 (27060): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B5 (27061): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B6 (27062): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B7 (27063): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B8 (27064): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069B9 (27065): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069BA (27066): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069BB (27067): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069BC (27068): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069BD (27069): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069BE (27070): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069BF (27071): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C0 (27072): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C1 (27073): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C2 (27074): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C3 (27075): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C4 (27076): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C5 (27077): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C6 (27078): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C7 (27079): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C8 (27080): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069C9 (27081): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069CA (27082): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069CB (27083): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069CC (27084): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069CD (27085): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069CE (27086): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069CF (27087): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D0 (27088): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D1 (27089): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D2 (27090): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D3 (27091): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D4 (27092): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D5 (27093): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D6 (27094): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D7 (27095): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D8 (27096): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069D9 (27097): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069DA (27098): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069DB (27099): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069DC (27100): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069DD (27101): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069DE (27102): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069DF (27103): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E0 (27104): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E1 (27105): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E2 (27106): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E3 (27107): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E4 (27108): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E5 (27109): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E6 (27110): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E7 (27111): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E8 (27112): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069E9 (27113): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069EA (27114): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069EB (27115): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069EC (27116): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069ED (27117): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069EE (27118): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069EF (27119): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069F0 (27120): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069F1 (27121): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069F2 (27122): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069F3 (27123): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x069F4 (27124): - Valores distintos (7): 0x00, 0x1C, 0x46, 0x47, 0x4E, 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x46 -> 75 veces - 0x47 -> 50 veces - 0x1C -> 27 veces - 0x52 -> 27 veces - 0x00 -> 25 veces - -Offset 0x069F5 (27125): - Valores distintos (7): 0x00, 0x02, 0x47, 0x48, 0x49, 0x4F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x47 -> 75 veces - 0x48 -> 50 veces - 0x02 -> 27 veces - 0x49 -> 27 veces - 0x00 -> 25 veces - -Offset 0x069F6 (27126): - Valores distintos (8): 0x00, 0x04, 0x06, 0x14, 0x1D, 0x46, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x48 -> 75 veces - 0x1D -> 27 veces - 0x46 -> 27 veces - 0x00 -> 25 veces - 0x04 -> 25 veces - -Offset 0x069F7 (27127): - Valores distintos (7): 0x00, 0x20, 0x45, 0x47, 0x49, 0x4C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x49 -> 75 veces - 0x20 -> 42 veces - 0x00 -> 36 veces - 0x47 -> 27 veces - 0x45 -> 24 veces - -Offset 0x069F8 (27128): - Valores distintos (6): 0x00, 0x07, 0x12, 0x39, 0x48, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x07 -> 75 veces - 0x48 -> 27 veces - 0x39 -> 25 veces - 0x12 -> 21 veces - -Offset 0x069F9 (27129): - Valores distintos (6): 0x00, 0x07, 0x29, 0x33, 0x3A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x3A -> 75 veces - 0x07 -> 27 veces - 0x29 -> 25 veces - 0x33 -> 21 veces - -Offset 0x069FA (27130): - Valores distintos (6): 0x00, 0x04, 0x06, 0x21, 0x40, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x06 -> 75 veces - 0x21 -> 27 veces - 0x04 -> 25 veces - 0x40 -> 21 veces - -Offset 0x069FB (27131): - Valores distintos (6): 0x00, 0x06, 0x11, 0x1F, 0x20, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x20 -> 75 veces - 0x06 -> 27 veces - 0x1F -> 25 veces - 0x11 -> 21 veces - -Offset 0x069FC (27132): - Valores distintos (6): 0x00, 0x20, 0x38, 0x39, 0x4A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x39 -> 75 veces - 0x20 -> 27 veces - 0x38 -> 25 veces - 0x4A -> 21 veces - -Offset 0x069FD (27133): - Valores distintos (6): 0x00, 0x03, 0x29, 0x39, 0x49, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x29 -> 75 veces - 0x39 -> 27 veces - 0x03 -> 25 veces - 0x49 -> 21 veces - -Offset 0x069FE (27134): - Valores distintos (6): 0x00, 0x02, 0x04, 0x29, 0x4D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x04 -> 75 veces - 0x29 -> 27 veces - 0x02 -> 25 veces - 0x4D -> 21 veces - -Offset 0x069FF (27135): - Valores distintos (6): 0x00, 0x04, 0x10, 0x1C, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x1F -> 75 veces - 0x04 -> 27 veces - 0x1C -> 25 veces - 0x10 -> 21 veces - -Offset 0x06A00 (27136): - Valores distintos (5): 0x00, 0x1F, 0x26, 0x38, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x38 -> 75 veces - 0x1F -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A01 (27137): - Valores distintos (5): 0x00, 0x03, 0x0E, 0x38, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x03 -> 75 veces - 0x38 -> 27 veces - 0x0E -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A02 (27138): - Valores distintos (5): 0x00, 0x02, 0x03, 0x42, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x02 -> 75 veces - 0x03 -> 27 veces - 0x42 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A03 (27139): - Valores distintos (5): 0x00, 0x09, 0x0C, 0x1C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x1C -> 75 veces - 0x09 -> 27 veces - 0x0C -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A04 (27140): - Valores distintos (4): 0x00, 0x1C, 0x46, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x1C -> 27 veces - 0x46 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A05 (27141): - Valores distintos (4): 0x00, 0x02, 0x3D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 27 veces - 0x3D -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A06 (27142): - Valores distintos (4): 0x00, 0x0A, 0x47, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0A -> 27 veces - 0x47 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A07 (27143): - Valores distintos (4): 0x00, 0x48, 0x4A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4A -> 27 veces - 0x48 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A08 (27144): - Valores distintos (4): 0x00, 0x24, 0x3A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3A -> 27 veces - 0x24 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A09 (27145): - Valores distintos (4): 0x00, 0x0A, 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x24 -> 27 veces - 0x0A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A0A (27146): - Valores distintos (4): 0x00, 0x08, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0C -> 27 veces - 0x08 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A0B (27147): - Valores distintos (4): 0x00, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x11 -> 27 veces - 0x09 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A0C (27148): - Valores distintos (4): 0x00, 0x07, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0E -> 27 veces - 0x07 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A0D (27149): - Valores distintos (4): 0x00, 0x21, 0x42, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x42 -> 27 veces - 0x21 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A0E (27150): - Valores distintos (4): 0x00, 0x33, 0x3A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x33 -> 27 veces - 0x3A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A0F (27151): - Valores distintos (4): 0x00, 0x2A, 0x4C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4C -> 27 veces - 0x2A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A10 (27152): - Valores distintos (4): 0x00, 0x06, 0x3D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3D -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A11 (27153): - Valores distintos (4): 0x00, 0x20, 0x4D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4D -> 27 veces - 0x20 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A12 (27154): - Valores distintos (4): 0x00, 0x14, 0x39, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x14 -> 27 veces - 0x39 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A13 (27155): - Valores distintos (3): 0x00, 0x29, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x29 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A14 (27156): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A15 (27157): - Valores distintos (3): 0x00, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x1F -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A16 (27158): - Valores distintos (3): 0x00, 0x38, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x38 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A17 (27159): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A18 (27160): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A19 (27161): - Valores distintos (3): 0x00, 0x1C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x1C -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A1A (27162): - Valores distintos (3): 0x00, 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x4B -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A1B (27163): - Valores distintos (3): 0x00, 0x35, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x35 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A1C (27164): - Valores distintos (3): 0x00, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x16 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06A1D (27165): - Valores distintos (3): 0x00, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x15 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06A1E (27166): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A1F (27167): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A20 (27168): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A21 (27169): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A22 (27170): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A23 (27171): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A24 (27172): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A25 (27173): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A26 (27174): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A27 (27175): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A28 (27176): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A29 (27177): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A2A (27178): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A2B (27179): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A2C (27180): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A2D (27181): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A2E (27182): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A2F (27183): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A30 (27184): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A31 (27185): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A32 (27186): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A33 (27187): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A34 (27188): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A35 (27189): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A36 (27190): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A37 (27191): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A38 (27192): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A39 (27193): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A3A (27194): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A3B (27195): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A3C (27196): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A3D (27197): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A3E (27198): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A3F (27199): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A40 (27200): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A41 (27201): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A42 (27202): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A43 (27203): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A44 (27204): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A45 (27205): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A46 (27206): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A47 (27207): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A48 (27208): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A49 (27209): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A4A (27210): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A4B (27211): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A4C (27212): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A4D (27213): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A4E (27214): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A4F (27215): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A50 (27216): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A51 (27217): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A52 (27218): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A53 (27219): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A54 (27220): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A55 (27221): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A56 (27222): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A57 (27223): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A58 (27224): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A59 (27225): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A5A (27226): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A5B (27227): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A5C (27228): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A5D (27229): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A5E (27230): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A5F (27231): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A60 (27232): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A61 (27233): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A62 (27234): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A63 (27235): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A64 (27236): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A65 (27237): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A66 (27238): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A67 (27239): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A68 (27240): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A69 (27241): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A6A (27242): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A6B (27243): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A6C (27244): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A6D (27245): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A6E (27246): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A6F (27247): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A70 (27248): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A71 (27249): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A72 (27250): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A73 (27251): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A74 (27252): - Valores distintos (3): 0x00, 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x32 -> 150 veces - 0x00 -> 75 veces - 0xFF -> 9 veces - -Offset 0x06A75 (27253): - Valores distintos (5): 0x00, 0x05, 0x21, 0x33, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 100 veces - 0x00 -> 52 veces - 0x33 -> 48 veces - 0x05 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06A76 (27254): - Valores distintos (5): 0x00, 0x23, 0x29, 0x36, 0xFF - Clasificación: small_state - Más frecuentes: - 0x23 -> 102 veces - 0x00 -> 75 veces - 0x29 -> 27 veces - 0x36 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A77 (27255): - Valores distintos (5): 0x00, 0x06, 0x21, 0x38, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 100 veces - 0x00 -> 77 veces - 0x21 -> 27 veces - 0x38 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A78 (27256): - Valores distintos (5): 0x00, 0x05, 0x23, 0x3E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 100 veces - 0x00 -> 77 veces - 0x23 -> 27 veces - 0x3E -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A79 (27257): - Valores distintos (5): 0x00, 0x03, 0x26, 0x3A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 100 veces - 0x00 -> 77 veces - 0x26 -> 27 veces - 0x3A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A7A (27258): - Valores distintos (6): 0x00, 0x06, 0x08, 0x36, 0x3D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x08 -> 75 veces - 0x36 -> 27 veces - 0x06 -> 25 veces - 0x3D -> 21 veces - -Offset 0x06A7B (27259): - Valores distintos (5): 0x00, 0x0B, 0x0C, 0x29, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x0B -> 75 veces - 0x0C -> 27 veces - 0x29 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A7C (27260): - Valores distintos (5): 0x00, 0x0E, 0x11, 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x0E -> 75 veces - 0x11 -> 27 veces - 0x21 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A7D (27261): - Valores distintos (5): 0x00, 0x06, 0x0C, 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x0C -> 75 veces - 0x06 -> 27 veces - 0x23 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A7E (27262): - Valores distintos (5): 0x00, 0x05, 0x0A, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x0A -> 72 veces - 0x05 -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A7F (27263): - Valores distintos (5): 0x00, 0x03, 0x27, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x28 -> 72 veces - 0x03 -> 27 veces - 0x27 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A80 (27264): - Valores distintos (4): 0x00, 0x08, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x08 -> 27 veces - 0x28 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A81 (27265): - Valores distintos (4): 0x00, 0x0E, 0x2C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0E -> 27 veces - 0x2C -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A82 (27266): - Valores distintos (4): 0x00, 0x0A, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0A -> 27 veces - 0x0C -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A83 (27267): - Valores distintos (4): 0x00, 0x10, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x10 -> 27 veces - 0x11 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A84 (27268): - Valores distintos (4): 0x00, 0x06, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0B -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A85 (27269): - Valores distintos (4): 0x00, 0x05, 0x27, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x27 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A86 (27270): - Valores distintos (4): 0x00, 0x03, 0x3E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3E -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A87 (27271): - Valores distintos (4): 0x00, 0x08, 0x3A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3A -> 27 veces - 0x08 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A88 (27272): - Valores distintos (4): 0x00, 0x0E, 0x12, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x12 -> 27 veces - 0x0E -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A89 (27273): - Valores distintos (4): 0x00, 0x0A, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x16 -> 27 veces - 0x0A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A8A (27274): - Valores distintos (4): 0x00, 0x10, 0x1A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x1A -> 27 veces - 0x10 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A8B (27275): - Valores distintos (4): 0x00, 0x0B, 0x3B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3B -> 27 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A8C (27276): - Valores distintos (3): 0x00, 0x17, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x17 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A8D (27277): - Valores distintos (3): 0x00, 0x12, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x12 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A8E (27278): - Valores distintos (3): 0x00, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x16 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A8F (27279): - Valores distintos (3): 0x00, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x14 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A90 (27280): - Valores distintos (3): 0x00, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x15 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A91 (27281): - Valores distintos (3): 0x00, 0x2A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x2A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A92 (27282): - Valores distintos (3): 0x00, 0x3B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x3B -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A93 (27283): - Valores distintos (3): 0x00, 0x2B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x2B -> 21 veces - 0xFF -> 9 veces - -Offset 0x06A94 (27284): - Valores distintos (3): 0x00, 0x1E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x1E -> 12 veces - 0xFF -> 9 veces - -Offset 0x06A95 (27285): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A96 (27286): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A97 (27287): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A98 (27288): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A99 (27289): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A9A (27290): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A9B (27291): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A9C (27292): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A9D (27293): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A9E (27294): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06A9F (27295): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA0 (27296): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA1 (27297): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA2 (27298): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA3 (27299): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA4 (27300): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA5 (27301): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA6 (27302): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA7 (27303): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA8 (27304): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AA9 (27305): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AAA (27306): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AAB (27307): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AAC (27308): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AAD (27309): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AAE (27310): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AAF (27311): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB0 (27312): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB1 (27313): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB2 (27314): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB3 (27315): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB4 (27316): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB5 (27317): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB6 (27318): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB7 (27319): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB8 (27320): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AB9 (27321): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ABA (27322): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ABB (27323): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ABC (27324): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ABD (27325): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ABE (27326): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ABF (27327): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC0 (27328): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC1 (27329): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC2 (27330): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC3 (27331): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC4 (27332): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC5 (27333): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC6 (27334): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC7 (27335): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC8 (27336): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AC9 (27337): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ACA (27338): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ACB (27339): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ACC (27340): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ACD (27341): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ACE (27342): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ACF (27343): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD0 (27344): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD1 (27345): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD2 (27346): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD3 (27347): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD4 (27348): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD5 (27349): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD6 (27350): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD7 (27351): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD8 (27352): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AD9 (27353): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ADA (27354): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ADB (27355): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ADC (27356): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ADD (27357): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ADE (27358): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ADF (27359): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE0 (27360): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE1 (27361): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE2 (27362): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE3 (27363): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE4 (27364): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE5 (27365): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE6 (27366): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE7 (27367): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE8 (27368): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AE9 (27369): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AEA (27370): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AEB (27371): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AEC (27372): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AED (27373): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AEE (27374): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AEF (27375): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AF0 (27376): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AF1 (27377): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AF2 (27378): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AF3 (27379): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06AF4 (27380): - Valores distintos (4): 0x18, 0x1C, 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x18 -> 148 veces - 0x1C -> 52 veces - 0x21 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06AF5 (27381): - Valores distintos (6): 0x00, 0x09, 0x0A, 0x1F, 0x25, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 100 veces - 0x09 -> 48 veces - 0x1F -> 47 veces - 0x25 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06AF6 (27382): - Valores distintos (6): 0x00, 0x09, 0x11, 0x1C, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x09 -> 75 veces - 0x00 -> 55 veces - 0x11 -> 48 veces - 0x1C -> 25 veces - 0x28 -> 22 veces - -Offset 0x06AF7 (27383): - Valores distintos (6): 0x00, 0x0E, 0x13, 0x1D, 0x1F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0E -> 75 veces - 0x00 -> 55 veces - 0x13 -> 48 veces - 0x1F -> 25 veces - 0x1D -> 22 veces - -Offset 0x06AF8 (27384): - Valores distintos (6): 0x00, 0x05, 0x12, 0x24, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 75 veces - 0x00 -> 55 veces - 0x12 -> 48 veces - 0x28 -> 25 veces - 0x24 -> 22 veces - -Offset 0x06AF9 (27385): - Valores distintos (6): 0x00, 0x04, 0x0E, 0x1D, 0x29, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x29 -> 75 veces - 0x0E -> 36 veces - 0x1D -> 25 veces - 0x04 -> 12 veces - -Offset 0x06AFA (27386): - Valores distintos (6): 0x00, 0x0A, 0x21, 0x24, 0x29, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 100 veces - 0x00 -> 52 veces - 0x29 -> 27 veces - 0x24 -> 25 veces - 0x0A -> 21 veces - -Offset 0x06AFB (27387): - Valores distintos (6): 0x00, 0x10, 0x21, 0x25, 0x2F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x25 -> 100 veces - 0x00 -> 52 veces - 0x21 -> 27 veces - 0x2F -> 25 veces - 0x10 -> 21 veces - -Offset 0x06AFC (27388): - Valores distintos (6): 0x00, 0x08, 0x12, 0x1C, 0x25, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1C -> 100 veces - 0x00 -> 69 veces - 0x25 -> 27 veces - 0x08 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06AFD (27389): - Valores distintos (6): 0x00, 0x16, 0x1C, 0x1F, 0x2C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1F -> 100 veces - 0x00 -> 60 veces - 0x1C -> 27 veces - 0x16 -> 21 veces - 0x2C -> 17 veces - -Offset 0x06AFE (27390): - Valores distintos (5): 0x00, 0x06, 0x1F, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x28 -> 100 veces - 0x00 -> 77 veces - 0x1F -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06AFF (27391): - Valores distintos (6): 0x00, 0x02, 0x0C, 0x1D, 0x28, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1D -> 100 veces - 0x00 -> 77 veces - 0x28 -> 27 veces - 0x02 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06B00 (27392): - Valores distintos (5): 0x00, 0x0B, 0x1D, 0x24, 0xFF - Clasificación: small_state - Más frecuentes: - 0x24 -> 100 veces - 0x00 -> 89 veces - 0x1D -> 27 veces - 0xFF -> 9 veces - 0x0B -> 9 veces - -Offset 0x06B01 (27393): - Valores distintos (5): 0x00, 0x24, 0x29, 0x2C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x2C -> 100 veces - 0x00 -> 77 veces - 0x24 -> 27 veces - 0x29 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B02 (27394): - Valores distintos (5): 0x00, 0x20, 0x21, 0x2C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x20 -> 100 veces - 0x00 -> 77 veces - 0x2C -> 27 veces - 0x21 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B03 (27395): - Valores distintos (6): 0x00, 0x20, 0x22, 0x25, 0x2E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x22 -> 75 veces - 0x20 -> 27 veces - 0x2E -> 25 veces - 0x25 -> 21 veces - -Offset 0x06B04 (27396): - Valores distintos (5): 0x00, 0x1C, 0x22, 0x2E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x2E -> 75 veces - 0x22 -> 27 veces - 0x1C -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B05 (27397): - Valores distintos (5): 0x00, 0x1F, 0x2E, 0x30, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x30 -> 75 veces - 0x2E -> 27 veces - 0x1F -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B06 (27398): - Valores distintos (5): 0x00, 0x04, 0x28, 0x2F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x04 -> 72 veces - 0x2F -> 27 veces - 0x28 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B07 (27399): - Valores distintos (4): 0x00, 0x1D, 0x1E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x1E -> 27 veces - 0x1D -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B08 (27400): - Valores distintos (4): 0x00, 0x24, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x26 -> 27 veces - 0x24 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B09 (27401): - Valores distintos (4): 0x00, 0x0A, 0x2C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0A -> 27 veces - 0x2C -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B0A (27402): - Valores distintos (4): 0x00, 0x10, 0x20, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x10 -> 27 veces - 0x20 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B0B (27403): - Valores distintos (4): 0x00, 0x22, 0x30, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x30 -> 27 veces - 0x22 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B0C (27404): - Valores distintos (4): 0x00, 0x1E, 0x2B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x2B -> 27 veces - 0x1E -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B0D (27405): - Valores distintos (3): 0x00, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B0E (27406): - Valores distintos (3): 0x00, 0x2B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x2B -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B0F (27407): - Valores distintos (3): 0x00, 0x23, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x23 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B10 (27408): - Valores distintos (3): 0x00, 0x2E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x2E -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B11 (27409): - Valores distintos (3): 0x00, 0x2F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x2F -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B12 (27410): - Valores distintos (3): 0x00, 0x30, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x30 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B13 (27411): - Valores distintos (3): 0x00, 0x32, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x32 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B14 (27412): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x0F -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B15 (27413): - Valores distintos (3): 0x00, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x15 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B16 (27414): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B17 (27415): - Valores distintos (3): 0x00, 0x19, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x19 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B18 (27416): - Valores distintos (3): 0x00, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x14 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B19 (27417): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B1A (27418): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B1B (27419): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B1C (27420): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B1D (27421): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B1E (27422): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B1F (27423): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B20 (27424): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B21 (27425): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B22 (27426): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B23 (27427): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B24 (27428): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B25 (27429): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B26 (27430): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B27 (27431): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B28 (27432): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B29 (27433): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B2A (27434): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B2B (27435): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B2C (27436): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B2D (27437): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B2E (27438): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B2F (27439): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B30 (27440): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B31 (27441): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B32 (27442): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B33 (27443): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B34 (27444): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B35 (27445): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B36 (27446): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B37 (27447): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B38 (27448): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B39 (27449): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B3A (27450): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B3B (27451): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B3C (27452): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B3D (27453): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B3E (27454): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B3F (27455): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B40 (27456): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B41 (27457): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B42 (27458): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B43 (27459): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B44 (27460): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B45 (27461): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B46 (27462): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B47 (27463): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B48 (27464): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B49 (27465): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B4A (27466): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B4B (27467): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B4C (27468): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B4D (27469): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B4E (27470): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B4F (27471): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B50 (27472): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B51 (27473): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B52 (27474): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B53 (27475): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B54 (27476): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B55 (27477): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B56 (27478): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B57 (27479): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B58 (27480): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B59 (27481): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B5A (27482): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B5B (27483): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B5C (27484): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B5D (27485): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B5E (27486): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B5F (27487): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B60 (27488): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B61 (27489): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B62 (27490): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B63 (27491): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B64 (27492): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B65 (27493): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B66 (27494): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B67 (27495): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B68 (27496): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B69 (27497): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B6A (27498): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B6B (27499): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B6C (27500): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B6D (27501): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B6E (27502): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B6F (27503): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B70 (27504): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B71 (27505): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B72 (27506): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B73 (27507): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06B74 (27508): - Valores distintos (9): 0x02, 0x03, 0x04, 0x05, 0x08, 0x09, 0x0B, 0x12, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x12 -> 75 veces - 0x04 -> 30 veces - 0x08 -> 30 veces - 0x0B -> 25 veces - 0x05 -> 22 veces - -Offset 0x06B75 (27509): - Valores distintos (6): 0x01, 0x02, 0x03, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 102 veces - 0x02 -> 75 veces - 0x03 -> 27 veces - 0x0A -> 12 veces - 0xFF -> 9 veces - -Offset 0x06B76 (27510): - Valores distintos (12): 0x02, 0x03, 0x04, 0x05, 0x11, 0x12, 0x1B, 0x1E, 0x20, 0x21, 0x28, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x21 -> 75 veces - 0x28 -> 48 veces - 0x20 -> 25 veces - 0x12 -> 21 veces - 0x05 -> 20 veces - -Offset 0x06B77 (27511): - Valores distintos (12): 0x04, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x10, 0x15, 0x17, 0x19, 0x20, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x17 -> 72 veces - 0x19 -> 27 veces - 0x10 -> 25 veces - 0x07 -> 23 veces - 0x08 -> 21 veces - -Offset 0x06B78 (27512): - Valores distintos (8): 0x01, 0x05, 0x08, 0x09, 0x0C, 0x15, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0C -> 100 veces - 0x16 -> 39 veces - 0x01 -> 30 veces - 0x05 -> 22 veces - 0x09 -> 17 veces - -Offset 0x06B79 (27513): - Valores distintos (8): 0x01, 0x04, 0x05, 0x09, 0x0A, 0x0B, 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 96 veces - 0x0B -> 42 veces - 0x0D -> 36 veces - 0x01 -> 30 veces - 0x0A -> 12 veces - -Offset 0x06B7A (27514): - Valores distintos (3): 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 193 veces - 0x02 -> 32 veces - 0xFF -> 9 veces - -Offset 0x06B7B (27515): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 123 veces - 0x03 -> 47 veces - 0x05 -> 25 veces - 0x01 -> 24 veces - 0xFF -> 9 veces - -Offset 0x06B7C (27516): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 95 veces - 0x02 -> 50 veces - 0x0E -> 48 veces - 0x01 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06B7D (27517): - Valores distintos (8): 0x00, 0x01, 0x03, 0x05, 0x06, 0x07, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 75 veces - 0x03 -> 57 veces - 0x01 -> 50 veces - 0x0E -> 17 veces - 0x06 -> 12 veces - -Offset 0x06B7E (27518): - Valores distintos (6): 0x00, 0x01, 0x02, 0x03, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 125 veces - 0x04 -> 34 veces - 0x00 -> 30 veces - 0x02 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06B7F (27519): - Valores distintos (5): 0x00, 0x01, 0x02, 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 77 veces - 0x02 -> 75 veces - 0x0D -> 48 veces - 0x00 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06B80 (27520): - Valores distintos (7): 0x00, 0x01, 0x04, 0x06, 0x0B, 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0D -> 100 veces - 0x04 -> 56 veces - 0x01 -> 22 veces - 0x0B -> 22 veces - 0x06 -> 17 veces - -Offset 0x06B81 (27521): - Valores distintos (4): 0x00, 0x01, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 117 veces - 0x04 -> 100 veces - 0xFF -> 9 veces - 0x00 -> 8 veces - -Offset 0x06B82 (27522): - Valores distintos (6): 0x00, 0x01, 0x02, 0x16, 0x1B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 142 veces - 0x02 -> 48 veces - 0x1B -> 17 veces - 0x00 -> 10 veces - 0xFF -> 9 veces - -Offset 0x06B83 (27523): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 92 veces - 0x02 -> 75 veces - 0x04 -> 48 veces - 0x00 -> 10 veces - 0xFF -> 9 veces - -Offset 0x06B84 (27524): - Valores distintos (5): 0x00, 0x01, 0x02, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 149 veces - 0x00 -> 30 veces - 0x02 -> 25 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B85 (27525): - Valores distintos (6): 0x00, 0x01, 0x02, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 75 veces - 0x05 -> 48 veces - 0x01 -> 46 veces - 0x00 -> 31 veces - 0x02 -> 25 veces - -Offset 0x06B86 (27526): - Valores distintos (4): 0x00, 0x01, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 148 veces - 0x00 -> 52 veces - 0x04 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06B87 (27527): - Valores distintos (5): 0x00, 0x01, 0x02, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 83 veces - 0x01 -> 69 veces - 0x00 -> 52 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B88 (27528): - Valores distintos (6): 0x00, 0x01, 0x03, 0x06, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 125 veces - 0x00 -> 52 veces - 0x06 -> 27 veces - 0x03 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06B89 (27529): - Valores distintos (5): 0x00, 0x01, 0x08, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 100 veces - 0x00 -> 77 veces - 0x09 -> 27 veces - 0x08 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B8A (27530): - Valores distintos (5): 0x00, 0x01, 0x02, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 100 veces - 0x00 -> 77 veces - 0x08 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B8B (27531): - Valores distintos (5): 0x00, 0x01, 0x06, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 102 veces - 0x00 -> 77 veces - 0x06 -> 25 veces - 0x54 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B8C (27532): - Valores distintos (6): 0x00, 0x01, 0x02, 0x05, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x02 -> 75 veces - 0x0A -> 27 veces - 0x01 -> 25 veces - 0x05 -> 21 veces - -Offset 0x06B8D (27533): - Valores distintos (4): 0x00, 0x01, 0x1C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 96 veces - 0x00 -> 77 veces - 0x1C -> 52 veces - 0xFF -> 9 veces - -Offset 0x06B8E (27534): - Valores distintos (6): 0x00, 0x01, 0x03, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x04 -> 75 veces - 0x03 -> 36 veces - 0x01 -> 25 veces - 0x05 -> 12 veces - -Offset 0x06B8F (27535): - Valores distintos (6): 0x00, 0x01, 0x03, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 100 veces - 0x00 -> 77 veces - 0x03 -> 27 veces - 0x05 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06B90 (27536): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x03 -> 75 veces - 0x02 -> 52 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B91 (27537): - Valores distintos (4): 0x00, 0x01, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 127 veces - 0x00 -> 77 veces - 0x08 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B92 (27538): - Valores distintos (6): 0x00, 0x01, 0x02, 0x08, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x0A -> 75 veces - 0x08 -> 27 veces - 0x01 -> 25 veces - 0x02 -> 21 veces - -Offset 0x06B93 (27539): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 127 veces - 0x00 -> 77 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B94 (27540): - Valores distintos (6): 0x00, 0x01, 0x08, 0x09, 0x1C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x1C -> 75 veces - 0x09 -> 27 veces - 0x01 -> 25 veces - 0x08 -> 21 veces - -Offset 0x06B95 (27541): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x02 -> 75 veces - 0x01 -> 52 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B96 (27542): - Valores distintos (5): 0x00, 0x02, 0x03, 0x22, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 102 veces - 0x00 -> 77 veces - 0x02 -> 25 veces - 0x22 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B97 (27543): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x04 -> 75 veces - 0x02 -> 27 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B98 (27544): - Valores distintos (6): 0x00, 0x02, 0x0F, 0x10, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x02 -> 75 veces - 0x54 -> 27 veces - 0x10 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06B99 (27545): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0x04 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B9A (27546): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x02 -> 75 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06B9B (27547): - Valores distintos (5): 0x00, 0x01, 0x02, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0x02 -> 27 veces - 0x0A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B9C (27548): - Valores distintos (5): 0x00, 0x04, 0x07, 0x1D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x07 -> 75 veces - 0x04 -> 27 veces - 0x1D -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B9D (27549): - Valores distintos (5): 0x00, 0x01, 0x03, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x04 -> 75 veces - 0x01 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B9E (27550): - Valores distintos (5): 0x00, 0x01, 0x03, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0x04 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06B9F (27551): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 102 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA0 (27552): - Valores distintos (5): 0x00, 0x01, 0x03, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0x08 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA1 (27553): - Valores distintos (4): 0x00, 0x05, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 27 veces - 0x09 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA2 (27554): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA3 (27555): - Valores distintos (4): 0x00, 0x02, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 27 veces - 0x0A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA4 (27556): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA5 (27557): - Valores distintos (4): 0x00, 0x03, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0A -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA6 (27558): - Valores distintos (4): 0x00, 0x01, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x08 -> 27 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA7 (27559): - Valores distintos (4): 0x00, 0x03, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 27 veces - 0x09 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA8 (27560): - Valores distintos (4): 0x00, 0x05, 0x1A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x1A -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BA9 (27561): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BAA (27562): - Valores distintos (3): 0x00, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x0A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BAB (27563): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x09 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06BAC (27564): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BAD (27565): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BAE (27566): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BAF (27567): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB0 (27568): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB1 (27569): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB2 (27570): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB3 (27571): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB4 (27572): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB5 (27573): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB6 (27574): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB7 (27575): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB8 (27576): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BB9 (27577): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BBA (27578): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BBB (27579): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BBC (27580): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BBD (27581): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BBE (27582): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BBF (27583): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC0 (27584): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC1 (27585): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC2 (27586): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC3 (27587): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC4 (27588): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC5 (27589): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC6 (27590): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC7 (27591): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC8 (27592): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BC9 (27593): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BCA (27594): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BCB (27595): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BCC (27596): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BCD (27597): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BCE (27598): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BCF (27599): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD0 (27600): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD1 (27601): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD2 (27602): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD3 (27603): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD4 (27604): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD5 (27605): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD6 (27606): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD7 (27607): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD8 (27608): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BD9 (27609): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BDA (27610): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BDB (27611): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BDC (27612): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BDD (27613): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BDE (27614): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BDF (27615): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE0 (27616): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE1 (27617): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE2 (27618): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE3 (27619): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE4 (27620): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE5 (27621): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE6 (27622): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE7 (27623): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE8 (27624): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BE9 (27625): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BEA (27626): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BEB (27627): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BEC (27628): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BED (27629): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BEE (27630): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BEF (27631): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BF0 (27632): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BF1 (27633): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BF2 (27634): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BF3 (27635): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06BF4 (27636): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 200 veces - 0x00 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06BF5 (27637): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 125 veces - 0x03 -> 75 veces - 0x00 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06BF6 (27638): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 173 veces - 0x03 -> 27 veces - 0x00 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06BF7 (27639): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 137 veces - 0x00 -> 36 veces - 0x03 -> 27 veces - 0x02 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06BF8 (27640): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x02 -> 75 veces - 0x01 -> 73 veces - 0xFF -> 9 veces - -Offset 0x06BF9 (27641): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 121 veces - 0x00 -> 77 veces - 0x02 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06BFA (27642): - Valores distintos (4): 0x00, 0x01, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 127 veces - 0x00 -> 77 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06BFB (27643): - Valores distintos (5): 0x00, 0x01, 0x02, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x02 -> 75 veces - 0x01 -> 46 veces - 0x04 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06BFC (27644): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 121 veces - 0x00 -> 77 veces - 0x02 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06BFD (27645): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06BFE (27646): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06BFF (27647): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 100 veces - 0x00 -> 77 veces - 0x03 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C00 (27648): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06C01 (27649): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06C02 (27650): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06C03 (27651): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06C04 (27652): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C05 (27653): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C06 (27654): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C07 (27655): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C08 (27656): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C09 (27657): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C0A (27658): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C0B (27659): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C0C (27660): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C0D (27661): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C0E (27662): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C0F (27663): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C10 (27664): - Valores distintos (4): 0x00, 0x01, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C11 (27665): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C12 (27666): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C13 (27667): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C14 (27668): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C15 (27669): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C16 (27670): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C17 (27671): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C18 (27672): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C19 (27673): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C1A (27674): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C1B (27675): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C1C (27676): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x01 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06C1D (27677): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x01 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06C1E (27678): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C1F (27679): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C20 (27680): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C21 (27681): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C22 (27682): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C23 (27683): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C24 (27684): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C25 (27685): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C26 (27686): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C27 (27687): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C28 (27688): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C29 (27689): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C2A (27690): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C2B (27691): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C2C (27692): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C2D (27693): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C2E (27694): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C2F (27695): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C30 (27696): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C31 (27697): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C32 (27698): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C33 (27699): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C34 (27700): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C35 (27701): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C36 (27702): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C37 (27703): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C38 (27704): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C39 (27705): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C3A (27706): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C3B (27707): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C3C (27708): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C3D (27709): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C3E (27710): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C3F (27711): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C40 (27712): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C41 (27713): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C42 (27714): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C43 (27715): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C44 (27716): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C45 (27717): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C46 (27718): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C47 (27719): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C48 (27720): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C49 (27721): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C4A (27722): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C4B (27723): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C4C (27724): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C4D (27725): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C4E (27726): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C4F (27727): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C50 (27728): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C51 (27729): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C52 (27730): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C53 (27731): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C54 (27732): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C55 (27733): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C56 (27734): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C57 (27735): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C58 (27736): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C59 (27737): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C5A (27738): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C5B (27739): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C5C (27740): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C5D (27741): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C5E (27742): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C5F (27743): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C60 (27744): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C61 (27745): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C62 (27746): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C63 (27747): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C64 (27748): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C65 (27749): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C66 (27750): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C67 (27751): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C68 (27752): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C69 (27753): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C6A (27754): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C6B (27755): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C6C (27756): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C6D (27757): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C6E (27758): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C6F (27759): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C70 (27760): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C71 (27761): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C72 (27762): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C73 (27763): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C74 (27764): - Valores distintos (5): 0x00, 0x01, 0x03, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 75 veces - 0x04 -> 25 veces - 0xFF -> 9 veces - 0x03 -> 2 veces - -Offset 0x06C75 (27765): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 98 veces - 0x02 -> 75 veces - 0x00 -> 52 veces - 0xFF -> 9 veces - -Offset 0x06C76 (27766): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 129 veces - 0x00 -> 75 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C77 (27767): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x03 -> 75 veces - 0x02 -> 44 veces - 0x01 -> 29 veces - 0xFF -> 9 veces - -Offset 0x06C78 (27768): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 127 veces - 0x00 -> 77 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C79 (27769): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x02 -> 75 veces - 0x01 -> 73 veces - 0xFF -> 9 veces - -Offset 0x06C7A (27770): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 127 veces - 0x00 -> 77 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C7B (27771): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06C7C (27772): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x02 -> 96 veces - 0x01 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06C7D (27773): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 96 veces - 0x03 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06C7E (27774): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x01 -> 99 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C7F (27775): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x01 -> 93 veces - 0x03 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06C80 (27776): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 27 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C81 (27777): - Valores distintos (4): 0x00, 0x01, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x06 -> 27 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C82 (27778): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 27 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C83 (27779): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 27 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C84 (27780): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C85 (27781): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C86 (27782): - Valores distintos (4): 0x00, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C87 (27783): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C88 (27784): - Valores distintos (4): 0x00, 0x02, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C89 (27785): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C8A (27786): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C8B (27787): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06C8C (27788): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C8D (27789): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C8E (27790): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C8F (27791): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C90 (27792): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C91 (27793): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C92 (27794): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C93 (27795): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06C94 (27796): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x01 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06C95 (27797): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C96 (27798): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C97 (27799): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C98 (27800): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C99 (27801): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C9A (27802): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C9B (27803): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C9C (27804): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C9D (27805): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C9E (27806): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06C9F (27807): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA0 (27808): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA1 (27809): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA2 (27810): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA3 (27811): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA4 (27812): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA5 (27813): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA6 (27814): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA7 (27815): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA8 (27816): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CA9 (27817): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CAA (27818): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CAB (27819): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CAC (27820): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CAD (27821): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CAE (27822): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CAF (27823): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB0 (27824): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB1 (27825): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB2 (27826): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB3 (27827): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB4 (27828): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB5 (27829): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB6 (27830): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB7 (27831): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB8 (27832): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CB9 (27833): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CBA (27834): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CBB (27835): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CBC (27836): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CBD (27837): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CBE (27838): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CBF (27839): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC0 (27840): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC1 (27841): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC2 (27842): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC3 (27843): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC4 (27844): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC5 (27845): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC6 (27846): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC7 (27847): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC8 (27848): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CC9 (27849): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CCA (27850): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CCB (27851): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CCC (27852): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CCD (27853): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CCE (27854): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CCF (27855): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD0 (27856): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD1 (27857): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD2 (27858): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD3 (27859): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD4 (27860): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD5 (27861): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD6 (27862): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD7 (27863): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD8 (27864): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CD9 (27865): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CDA (27866): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CDB (27867): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CDC (27868): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CDD (27869): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CDE (27870): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CDF (27871): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE0 (27872): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE1 (27873): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE2 (27874): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE3 (27875): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE4 (27876): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE5 (27877): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE6 (27878): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE7 (27879): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE8 (27880): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CE9 (27881): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CEA (27882): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CEB (27883): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CEC (27884): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CED (27885): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CEE (27886): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CEF (27887): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CF0 (27888): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CF1 (27889): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CF2 (27890): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CF3 (27891): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06CF4 (27892): - Valores distintos (6): 0x01, 0x02, 0x03, 0x0A, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 100 veces - 0x03 -> 74 veces - 0x01 -> 30 veces - 0x0B -> 12 veces - 0xFF -> 9 veces - -Offset 0x06CF5 (27893): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 195 veces - 0x03 -> 25 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x06CF6 (27894): - Valores distintos (5): 0x00, 0x01, 0x03, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 55 veces - 0x03 -> 25 veces - 0x05 -> 22 veces - 0xFF -> 9 veces - -Offset 0x06CF7 (27895): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 136 veces - 0x00 -> 55 veces - 0x03 -> 21 veces - 0x02 -> 13 veces - 0xFF -> 9 veces - -Offset 0x06CF8 (27896): - Valores distintos (5): 0x00, 0x01, 0x05, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 145 veces - 0x00 -> 55 veces - 0x09 -> 17 veces - 0xFF -> 9 veces - 0x05 -> 8 veces - -Offset 0x06CF9 (27897): - Valores distintos (5): 0x00, 0x01, 0x03, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x06 -> 75 veces - 0x01 -> 48 veces - 0x03 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06CFA (27898): - Valores distintos (7): 0x00, 0x01, 0x02, 0x03, 0x06, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 75 veces - 0x00 -> 52 veces - 0x02 -> 37 veces - 0x15 -> 27 veces - 0x01 -> 25 veces - -Offset 0x06CFB (27899): - Valores distintos (6): 0x00, 0x01, 0x03, 0x07, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 75 veces - 0x00 -> 52 veces - 0x01 -> 46 veces - 0x15 -> 27 veces - 0x03 -> 25 veces - -Offset 0x06CFC (27900): - Valores distintos (6): 0x00, 0x01, 0x04, 0x05, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 75 veces - 0x00 -> 69 veces - 0x04 -> 46 veces - 0x14 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06CFD (27901): - Valores distintos (5): 0x00, 0x01, 0x02, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 126 veces - 0x00 -> 60 veces - 0x11 -> 27 veces - 0x02 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06CFE (27902): - Valores distintos (5): 0x00, 0x01, 0x04, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 100 veces - 0x00 -> 77 veces - 0x01 -> 27 veces - 0x04 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06CFF (27903): - Valores distintos (6): 0x00, 0x01, 0x03, 0x07, 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x0D -> 75 veces - 0x07 -> 27 veces - 0x03 -> 25 veces - 0x01 -> 21 veces - -Offset 0x06D00 (27904): - Valores distintos (5): 0x00, 0x01, 0x13, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x16 -> 100 veces - 0x00 -> 89 veces - 0x13 -> 27 veces - 0xFF -> 9 veces - 0x01 -> 9 veces - -Offset 0x06D01 (27905): - Valores distintos (6): 0x00, 0x02, 0x03, 0x14, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x03 -> 75 veces - 0x16 -> 27 veces - 0x02 -> 25 veces - 0x14 -> 21 veces - -Offset 0x06D02 (27906): - Valores distintos (5): 0x00, 0x05, 0x14, 0x15, 0xFF - Clasificación: small_state - Más frecuentes: - 0x14 -> 100 veces - 0x00 -> 77 veces - 0x05 -> 27 veces - 0x15 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D03 (27907): - Valores distintos (5): 0x00, 0x01, 0x02, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 77 veces - 0x02 -> 75 veces - 0x14 -> 48 veces - 0x01 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06D04 (27908): - Valores distintos (5): 0x00, 0x01, 0x0B, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0x0B -> 27 veces - 0x11 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D05 (27909): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06D06 (27910): - Valores distintos (4): 0x00, 0x01, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 105 veces - 0x01 -> 99 veces - 0x07 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D07 (27911): - Valores distintos (3): 0x00, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x14 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06D08 (27912): - Valores distintos (4): 0x00, 0x09, 0x16, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x09 -> 27 veces - 0x16 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D09 (27913): - Valores distintos (4): 0x00, 0x01, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D0A (27914): - Valores distintos (4): 0x00, 0x01, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x14 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D0B (27915): - Valores distintos (4): 0x00, 0x01, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D0C (27916): - Valores distintos (4): 0x00, 0x01, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x11 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D0D (27917): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x09 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D0E (27918): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D0F (27919): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D10 (27920): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D11 (27921): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D12 (27922): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D13 (27923): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D14 (27924): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D15 (27925): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D16 (27926): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x02 -> 12 veces - 0xFF -> 9 veces - 0x01 -> 9 veces - -Offset 0x06D17 (27927): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D18 (27928): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D19 (27929): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D1A (27930): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D1B (27931): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D1C (27932): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D1D (27933): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D1E (27934): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D1F (27935): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D20 (27936): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D21 (27937): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D22 (27938): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D23 (27939): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D24 (27940): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D25 (27941): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D26 (27942): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D27 (27943): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D28 (27944): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D29 (27945): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D2A (27946): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D2B (27947): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D2C (27948): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D2D (27949): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D2E (27950): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D2F (27951): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D30 (27952): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D31 (27953): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D32 (27954): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D33 (27955): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D34 (27956): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D35 (27957): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D36 (27958): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D37 (27959): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D38 (27960): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D39 (27961): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D3A (27962): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D3B (27963): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D3C (27964): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D3D (27965): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D3E (27966): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D3F (27967): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D40 (27968): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D41 (27969): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D42 (27970): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D43 (27971): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D44 (27972): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D45 (27973): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D46 (27974): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D47 (27975): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D48 (27976): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D49 (27977): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D4A (27978): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D4B (27979): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D4C (27980): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D4D (27981): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D4E (27982): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D4F (27983): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D50 (27984): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D51 (27985): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D52 (27986): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D53 (27987): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D54 (27988): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D55 (27989): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D56 (27990): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D57 (27991): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D58 (27992): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D59 (27993): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D5A (27994): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D5B (27995): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D5C (27996): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D5D (27997): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D5E (27998): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D5F (27999): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D60 (28000): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D61 (28001): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D62 (28002): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D63 (28003): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D64 (28004): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D65 (28005): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D66 (28006): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D67 (28007): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D68 (28008): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D69 (28009): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D6A (28010): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D6B (28011): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D6C (28012): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D6D (28013): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D6E (28014): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D6F (28015): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D70 (28016): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D71 (28017): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D72 (28018): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D73 (28019): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D74 (28020): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x03 -> 220 veces - 0xFF -> 9 veces - 0x00 -> 5 veces - -Offset 0x06D75 (28021): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 193 veces - 0x00 -> 32 veces - 0xFF -> 9 veces - -Offset 0x06D76 (28022): - Valores distintos (4): 0x00, 0x04, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 145 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - 0x0E -> 3 veces - -Offset 0x06D77 (28023): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06D78 (28024): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 123 veces - 0x00 -> 102 veces - 0xFF -> 9 veces - -Offset 0x06D79 (28025): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x09 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06D7A (28026): - Valores distintos (3): 0x00, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0A -> 48 veces - 0xFF -> 9 veces - -Offset 0x06D7B (28027): - Valores distintos (3): 0x00, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x06 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06D7C (28028): - Valores distintos (3): 0x00, 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x0D -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D7D (28029): - Valores distintos (3): 0x00, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x0C -> 12 veces - 0xFF -> 9 veces - -Offset 0x06D7E (28030): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D7F (28031): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D80 (28032): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D81 (28033): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D82 (28034): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D83 (28035): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D84 (28036): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D85 (28037): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D86 (28038): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D87 (28039): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D88 (28040): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D89 (28041): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D8A (28042): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D8B (28043): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D8C (28044): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D8D (28045): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D8E (28046): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D8F (28047): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D90 (28048): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D91 (28049): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D92 (28050): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D93 (28051): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D94 (28052): - Valores distintos (4): 0x00, 0x3E, 0x45, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 111 veces - 0x45 -> 93 veces - 0x3E -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D95 (28053): - Valores distintos (3): 0x00, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x14 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D96 (28054): - Valores distintos (3): 0x00, 0xAA, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xAA -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D97 (28055): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x0F -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D98 (28056): - Valores distintos (3): 0x00, 0xA3, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xA3 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D99 (28057): - Valores distintos (3): 0x00, 0xC4, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xC4 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D9A (28058): - Valores distintos (3): 0x00, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x0A -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D9B (28059): - Valores distintos (3): 0x00, 0xA4, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xA4 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06D9C (28060): - Valores distintos (3): 0x00, 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x10 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06D9D (28061): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D9E (28062): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06D9F (28063): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA0 (28064): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA1 (28065): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA2 (28066): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA3 (28067): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA4 (28068): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA5 (28069): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA6 (28070): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA7 (28071): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA8 (28072): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DA9 (28073): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DAA (28074): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DAB (28075): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DAC (28076): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DAD (28077): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DAE (28078): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DAF (28079): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB0 (28080): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB1 (28081): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB2 (28082): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB3 (28083): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB4 (28084): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB5 (28085): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB6 (28086): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB7 (28087): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB8 (28088): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DB9 (28089): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DBA (28090): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DBB (28091): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DBC (28092): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DBD (28093): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DBE (28094): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DBF (28095): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC0 (28096): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC1 (28097): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC2 (28098): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC3 (28099): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC4 (28100): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC5 (28101): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC6 (28102): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC7 (28103): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC8 (28104): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DC9 (28105): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DCA (28106): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DCB (28107): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DCC (28108): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DCD (28109): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DCE (28110): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DCF (28111): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD0 (28112): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD1 (28113): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD2 (28114): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD3 (28115): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD4 (28116): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD5 (28117): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD6 (28118): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD7 (28119): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD8 (28120): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DD9 (28121): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DDA (28122): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DDB (28123): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DDC (28124): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DDD (28125): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DDE (28126): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DDF (28127): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE0 (28128): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE1 (28129): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE2 (28130): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE3 (28131): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE4 (28132): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE5 (28133): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE6 (28134): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE7 (28135): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE8 (28136): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DE9 (28137): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DEA (28138): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DEB (28139): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DEC (28140): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DED (28141): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DEE (28142): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DEF (28143): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF0 (28144): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF1 (28145): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF2 (28146): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF3 (28147): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF4 (28148): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF5 (28149): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF6 (28150): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF7 (28151): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF8 (28152): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DF9 (28153): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DFA (28154): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DFB (28155): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DFC (28156): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DFD (28157): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DFE (28158): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06DFF (28159): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E00 (28160): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E01 (28161): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E02 (28162): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E03 (28163): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E04 (28164): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E05 (28165): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E06 (28166): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E07 (28167): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E08 (28168): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E09 (28169): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E0A (28170): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E0B (28171): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E0C (28172): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E0D (28173): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E0E (28174): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E0F (28175): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E10 (28176): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E11 (28177): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E12 (28178): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E13 (28179): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E14 (28180): - Valores distintos (6): 0x00, 0x01, 0x05, 0x06, 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x06 -> 102 veces - 0x01 -> 72 veces - 0x05 -> 25 veces - 0x08 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06E15 (28181): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E16 (28182): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E17 (28183): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E18 (28184): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E19 (28185): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E1A (28186): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 89 veces - 0x00 -> 76 veces - 0x01 -> 60 veces - 0xFF -> 9 veces - -Offset 0x06E1B (28187): - Valores distintos (3): 0x00, 0x1E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x1E -> 148 veces - 0x00 -> 77 veces - 0xFF -> 9 veces - -Offset 0x06E1C (28188): - Valores distintos (5): 0x00, 0x01, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 196 veces - 0x01 -> 23 veces - 0xFF -> 9 veces - 0x03 -> 5 veces - 0x02 -> 1 veces - -Offset 0x06E1D (28189): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E1E (28190): - Valores distintos (4): 0x00, 0x02, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 196 veces - 0x02 -> 26 veces - 0xFF -> 9 veces - 0x05 -> 3 veces - -Offset 0x06E1F (28191): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 214 veces - 0x02 -> 11 veces - 0xFF -> 9 veces - -Offset 0x06E20 (28192): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E21 (28193): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 220 veces - 0xFF -> 9 veces - 0x02 -> 5 veces - -Offset 0x06E22 (28194): - Valores distintos (4): 0x00, 0x02, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 172 veces - 0x02 -> 27 veces - 0x03 -> 26 veces - 0xFF -> 9 veces - -Offset 0x06E23 (28195): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E24 (28196): - Valores distintos (4): 0x00, 0x01, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 172 veces - 0x01 -> 28 veces - 0x02 -> 25 veces - 0xFF -> 9 veces - -Offset 0x06E25 (28197): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E26 (28198): - Valores distintos (5): 0x00, 0x03, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 151 veces - 0x03 -> 42 veces - 0x0A -> 20 veces - 0x0E -> 12 veces - 0xFF -> 9 veces - -Offset 0x06E27 (28199): - Valores distintos (8): 0x00, 0x03, 0x04, 0x05, 0x09, 0x0D, 0x14, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 75 veces - 0x03 -> 55 veces - 0x00 -> 37 veces - 0x0D -> 20 veces - 0x09 -> 17 veces - -Offset 0x06E28 (28200): - Valores distintos (5): 0x00, 0x01, 0x05, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 72 veces - 0x01 -> 52 veces - 0x00 -> 50 veces - 0xFF -> 39 veces - 0x11 -> 21 veces - -Offset 0x06E29 (28201): - Valores distintos (5): 0x06, 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 98 veces - 0x0A -> 97 veces - 0x09 -> 27 veces - 0x0E -> 9 veces - 0x06 -> 3 veces - -Offset 0x06E2A (28202): - Valores distintos (4): 0x04, 0x06, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 170 veces - 0x0A -> 30 veces - 0x06 -> 25 veces - 0x04 -> 9 veces - -Offset 0x06E2B (28203): - Valores distintos (7): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x02 -> 72 veces - 0x41 -> 52 veces - 0x20 -> 47 veces - 0xFF -> 39 veces - 0x08 -> 12 veces - -Offset 0x06E2C (28204): - Valores distintos (4): 0x00, 0x02, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 147 veces - 0xFF -> 39 veces - 0x02 -> 27 veces - 0x11 -> 21 veces - -Offset 0x06E2D (28205): - Valores distintos (4): 0x05, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 108 veces - 0xFF -> 78 veces - 0x05 -> 27 veces - 0x0E -> 21 veces - -Offset 0x06E2E (28206): - Valores distintos (3): 0x04, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 186 veces - 0x09 -> 27 veces - 0x04 -> 21 veces - -Offset 0x06E2F (28207): - Valores distintos (5): 0x04, 0x20, 0x21, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 108 veces - 0xFF -> 39 veces - 0x20 -> 39 veces - 0x62 -> 27 veces - 0x04 -> 21 veces - -Offset 0x06E30 (28208): - Valores distintos (5): 0x00, 0x01, 0x09, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 122 veces - 0xFF -> 61 veces - 0x09 -> 27 veces - 0x11 -> 21 veces - 0x01 -> 3 veces - -Offset 0x06E31 (28209): - Valores distintos (4): 0x06, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 98 veces - 0x06 -> 72 veces - 0x0A -> 55 veces - 0x0E -> 9 veces - -Offset 0x06E32 (28210): - Valores distintos (4): 0x04, 0x05, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 126 veces - 0x0A -> 72 veces - 0x05 -> 27 veces - 0x04 -> 9 veces - -Offset 0x06E33 (28211): - Valores distintos (7): 0x02, 0x04, 0x08, 0x20, 0x21, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 97 veces - 0xFF -> 61 veces - 0x02 -> 27 veces - 0x20 -> 25 veces - 0x08 -> 12 veces - -Offset 0x06E34 (28212): - Valores distintos (4): 0x00, 0x01, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 122 veces - 0xFF -> 61 veces - 0x01 -> 30 veces - 0x11 -> 21 veces - -Offset 0x06E35 (28213): - Valores distintos (4): 0x09, 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 123 veces - 0x0A -> 75 veces - 0x09 -> 27 veces - 0x0E -> 9 veces - -Offset 0x06E36 (28214): - Valores distintos (3): 0x04, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 198 veces - 0x0A -> 27 veces - 0x04 -> 9 veces - -Offset 0x06E37 (28215): - Valores distintos (6): 0x04, 0x08, 0x20, 0x21, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 72 veces - 0xFF -> 61 veces - 0x20 -> 50 veces - 0x41 -> 30 veces - 0x08 -> 12 veces - -Offset 0x06E38 (28216): - Valores distintos (5): 0x00, 0x01, 0x02, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 99 veces - 0xFF -> 69 veces - 0x00 -> 42 veces - 0x11 -> 21 veces - 0x02 -> 3 veces - -Offset 0x06E39 (28217): - Valores distintos (3): 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 127 veces - 0xFF -> 98 veces - 0x0E -> 9 veces - -Offset 0x06E3A (28218): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 225 veces - 0x04 -> 9 veces - -Offset 0x06E3B (28219): - Valores distintos (7): 0x04, 0x08, 0x20, 0x21, 0x41, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 99 veces - 0xFF -> 69 veces - 0x21 -> 25 veces - 0x20 -> 17 veces - 0x08 -> 12 veces - -Offset 0x06E3C (28220): - Valores distintos (4): 0x00, 0x01, 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 99 veces - 0xFF -> 69 veces - 0x00 -> 45 veces - 0x11 -> 21 veces - -Offset 0x06E3D (28221): - Valores distintos (3): 0x0A, 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 119 veces - 0xFF -> 106 veces - 0x0E -> 9 veces - -Offset 0x06E3E (28222): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 225 veces - 0x04 -> 9 veces - -Offset 0x06E3F (28223): - Valores distintos (6): 0x04, 0x08, 0x20, 0x21, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x41 -> 99 veces - 0xFF -> 69 veces - 0x20 -> 25 veces - 0x21 -> 20 veces - 0x08 -> 12 veces - -Offset 0x06E40 (28224): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 148 veces - 0xFF -> 86 veces - -Offset 0x06E41 (28225): - Valores distintos (2): 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0A -> 148 veces - 0xFF -> 86 veces - -Offset 0x06E43 (28227): - Valores distintos (2): 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x21 -> 148 veces - 0xFF -> 86 veces - -Offset 0x06E44 (28228): - Valores distintos (2): 0x11, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 213 veces - 0x11 -> 21 veces - -Offset 0x06E45 (28229): - Valores distintos (2): 0x0E, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 213 veces - 0x0E -> 21 veces - -Offset 0x06E46 (28230): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 213 veces - 0x04 -> 21 veces - -Offset 0x06E47 (28231): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 213 veces - 0x04 -> 21 veces - -Offset 0x06E70 (28272): - Valores distintos (6): 0x00, 0x01, 0x41, 0x47, 0xEF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xEF -> 75 veces - 0xFF -> 57 veces - 0x00 -> 30 veces - 0x41 -> 25 veces - 0x47 -> 25 veces - -Offset 0x06E71 (28273): - Valores distintos (4): 0x00, 0x0C, 0x0D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0D -> 75 veces - 0xFF -> 57 veces - 0x00 -> 52 veces - 0x0C -> 50 veces - -Offset 0x06E72 (28274): - Valores distintos (4): 0x00, 0x01, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06E73 (28275): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E74 (28276): - Valores distintos (7): 0x00, 0x02, 0x03, 0x23, 0x27, 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0xFF -> 132 veces - 0x27 -> 25 veces - 0x77 -> 25 veces - 0x03 -> 22 veces - 0x23 -> 21 veces - -Offset 0x06E75 (28277): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0xFF -> 57 veces - -Offset 0x06E76 (28278): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06E77 (28279): - Valores distintos (8): 0x00, 0x02, 0x03, 0x23, 0x27, 0x37, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0xBF -> 102 veces - 0xFF -> 30 veces - 0x27 -> 25 veces - 0x37 -> 25 veces - 0x03 -> 22 veces - -Offset 0x06E78 (28280): - Valores distintos (4): 0x00, 0x01, 0xFB, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 102 veces - 0x01 -> 75 veces - 0xFF -> 30 veces - 0xFB -> 27 veces - -Offset 0x06E79 (28281): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06E7A (28282): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E7B (28283): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E7C (28284): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E7D (28285): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E7E (28286): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E7F (28287): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E80 (28288): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E81 (28289): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E82 (28290): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E83 (28291): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E84 (28292): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E85 (28293): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E86 (28294): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E87 (28295): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E88 (28296): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E89 (28297): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E8A (28298): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E8B (28299): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E8C (28300): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E8D (28301): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E8E (28302): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E8F (28303): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E90 (28304): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E91 (28305): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E92 (28306): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E93 (28307): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E94 (28308): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E95 (28309): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E96 (28310): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E97 (28311): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E98 (28312): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E99 (28313): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E9A (28314): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E9B (28315): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E9C (28316): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E9D (28317): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E9E (28318): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06E9F (28319): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EA0 (28320): - Valores distintos (2): 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x52 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EA1 (28321): - Valores distintos (2): 0x79, 0xFF - Clasificación: small_state - Más frecuentes: - 0x79 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EA2 (28322): - Valores distintos (2): 0x75, 0xFF - Clasificación: small_state - Más frecuentes: - 0x75 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EA3 (28323): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EA4 (28324): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EA5 (28325): - Valores distintos (5): 0x00, 0x01, 0x05, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x07 -> 120 veces - 0x00 -> 77 veces - 0x01 -> 25 veces - 0xFF -> 9 veces - 0x05 -> 3 veces - -Offset 0x06EA6 (28326): - Valores distintos (8): 0x00, 0x01, 0x03, 0x04, 0x05, 0x07, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x0B -> 111 veces - 0xFF -> 39 veces - 0x01 -> 39 veces - 0x00 -> 25 veces - 0x03 -> 8 veces - -Offset 0x06EA7 (28327): - Valores distintos (6): 0x01, 0x03, 0x05, 0x08, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x05 -> 141 veces - 0xFF -> 69 veces - 0x08 -> 12 veces - 0x01 -> 8 veces - 0x0B -> 3 veces - -Offset 0x06EA8 (28328): - Valores distintos (14): 0x06, 0x08, 0x09, 0x0A, 0x0F, 0x11, 0x14, 0x15, 0x1A, 0x1B, 0x25, 0x33, 0x34, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 72 veces - 0x25 -> 27 veces - 0x15 -> 25 veces - 0x0F -> 22 veces - 0x0A -> 20 veces - -Offset 0x06EA9 (28329): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EAA (28330): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EAB (28331): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EAC (28332): - Valores distintos (15): 0x01, 0x03, 0x04, 0x05, 0x07, 0x08, 0x0B, 0x0D, 0x12, 0x1A, 0x1B, 0x2F, 0x42, 0x45, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1B -> 72 veces - 0x2F -> 27 veces - 0x12 -> 25 veces - 0x08 -> 21 veces - 0x05 -> 20 veces - -Offset 0x06EAD (28333): - Valores distintos (17): 0x03, 0x0C, 0x0F, 0x19, 0x1C, 0x1E, 0x1F, 0x26, 0x27, 0x28, 0x2B, 0x30, 0x31, 0x34, 0x3A, 0x3B, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x2B -> 71 veces - 0x30 -> 32 veces - 0x3A -> 25 veces - 0x03 -> 20 veces - 0x19 -> 20 veces - -Offset 0x06EAE (28334): - Valores distintos (17): 0x05, 0x07, 0x09, 0x0B, 0x12, 0x16, 0x1B, 0x1F, 0x22, 0x25, 0x26, 0x27, 0x2B, 0x31, 0x34, 0x36, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x07 -> 71 veces - 0x1F -> 37 veces - 0x25 -> 27 veces - 0x16 -> 25 veces - 0x1B -> 20 veces - -Offset 0x06EAF (28335): - Valores distintos (14): 0x01, 0x03, 0x04, 0x07, 0x09, 0x0A, 0x0B, 0x11, 0x14, 0x19, 0x1A, 0x1B, 0x1C, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x1A -> 71 veces - 0x11 -> 31 veces - 0x09 -> 25 veces - 0x19 -> 20 veces - 0x03 -> 20 veces - -Offset 0x06EB0 (28336): - Valores distintos (17): 0x02, 0x14, 0x19, 0x1F, 0x22, 0x3E, 0x46, 0x5F, 0x72, 0x96, 0xA3, 0xB0, 0xB9, 0xCC, 0xD1, 0xE8, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0xB0 -> 72 veces - 0x5F -> 27 veces - 0xB9 -> 25 veces - 0xE8 -> 20 veces - 0x1F -> 20 veces - -Offset 0x06EB1 (28337): - Valores distintos (14): 0x00, 0x02, 0x03, 0x11, 0x12, 0x1D, 0x2C, 0x32, 0x35, 0x54, 0x6D, 0x79, 0xE6, 0xFF - Clasificación: bitfield_like - Más frecuentes: - 0x79 -> 72 veces - 0xE6 -> 27 veces - 0x32 -> 25 veces - 0x03 -> 22 veces - 0x12 -> 21 veces - -Offset 0x06EB2 (28338): - Valores distintos (5): 0x00, 0x01, 0x09, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x0A -> 12 veces - 0xFF -> 9 veces - 0x09 -> 9 veces - -Offset 0x06EB3 (28339): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EB4 (28340): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 213 veces - 0x01 -> 12 veces - 0xFF -> 9 veces - -Offset 0x06EB5 (28341): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EB6 (28342): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EB7 (28343): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EB8 (28344): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EB9 (28345): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EBA (28346): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EBB (28347): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EBC (28348): - Valores distintos (2): 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x43 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EBD (28349): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EBE (28350): - Valores distintos (2): 0x20, 0xFF - Clasificación: small_state - Más frecuentes: - 0x20 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EBF (28351): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC0 (28352): - Valores distintos (2): 0x80, 0xFF - Clasificación: small_state - Más frecuentes: - 0x80 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC1 (28353): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC2 (28354): - Valores distintos (2): 0x08, 0xFF - Clasificación: small_state - Más frecuentes: - 0x08 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC3 (28355): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC4 (28356): - Valores distintos (2): 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x04 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC5 (28357): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC6 (28358): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC7 (28359): - Valores distintos (2): 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x01 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC8 (28360): - Valores distintos (2): 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EC9 (28361): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ECA (28362): - Valores distintos (2): 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x43 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ECB (28363): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ECC (28364): - Valores distintos (2): 0x10, 0xFF - Clasificación: small_state - Más frecuentes: - 0x10 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ECD (28365): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ECE (28366): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ECF (28367): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ED0 (28368): - Valores distintos (3): 0x00, 0x21, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x21 -> 27 veces - 0xFF -> 9 veces - -Offset 0x06ED1 (28369): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ED2 (28370): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ED3 (28371): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ED4 (28372): - Valores distintos (3): 0x00, 0x85, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x85 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06ED5 (28373): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06ED6 (28374): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ED7 (28375): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06ED8 (28376): - Valores distintos (4): 0x00, 0x68, 0xD1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x68 -> 27 veces - 0xD1 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06ED9 (28377): - Valores distintos (4): 0x00, 0x04, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06EDA (28378): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EDB (28379): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EDC (28380): - Valores distintos (4): 0x00, 0x7C, 0xE5, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0xE5 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06EDD (28381): - Valores distintos (4): 0x00, 0x04, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06EDE (28382): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EDF (28383): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EE0 (28384): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EE1 (28385): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EE2 (28386): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EE3 (28387): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EE4 (28388): - Valores distintos (3): 0x00, 0xE3, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xE3 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EE5 (28389): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EE6 (28390): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EE7 (28391): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EE8 (28392): - Valores distintos (4): 0x00, 0xB5, 0xB9, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xB5 -> 27 veces - 0xB9 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06EE9 (28393): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EEA (28394): - Valores distintos (3): 0x00, 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x63 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EEB (28395): - Valores distintos (3): 0x00, 0x0A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0A -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EEC (28396): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x07 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EED (28397): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EEE (28398): - Valores distintos (3): 0x00, 0x0F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x0F -> 27 veces - 0xFF -> 9 veces - -Offset 0x06EEF (28399): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF0 (28400): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF1 (28401): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF2 (28402): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF3 (28403): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF4 (28404): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF5 (28405): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF6 (28406): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF7 (28407): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EF8 (28408): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EF9 (28409): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06EFA (28410): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EFB (28411): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EFC (28412): - Valores distintos (4): 0x00, 0x26, 0x5B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x5B -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06EFD (28413): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06EFE (28414): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06EFF (28415): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F00 (28416): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F01 (28417): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F02 (28418): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F03 (28419): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F04 (28420): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F05 (28421): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F06 (28422): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F07 (28423): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F08 (28424): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F09 (28425): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F0A (28426): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F0B (28427): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F0C (28428): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F0D (28429): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F0E (28430): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F0F (28431): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F10 (28432): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F11 (28433): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F12 (28434): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F13 (28435): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F14 (28436): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F15 (28437): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F16 (28438): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F17 (28439): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F18 (28440): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F19 (28441): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F1A (28442): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F1B (28443): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F1C (28444): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F1D (28445): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F1E (28446): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F1F (28447): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F20 (28448): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F21 (28449): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F22 (28450): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F23 (28451): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F24 (28452): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F25 (28453): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F26 (28454): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F27 (28455): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F28 (28456): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F29 (28457): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F2A (28458): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F2B (28459): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F2C (28460): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F2D (28461): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F2E (28462): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F2F (28463): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F30 (28464): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F31 (28465): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F32 (28466): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F33 (28467): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F34 (28468): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F35 (28469): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F36 (28470): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F37 (28471): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F38 (28472): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06F39 (28473): - Valores distintos (4): 0x00, 0x02, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06F3A (28474): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F3B (28475): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F3C (28476): - Valores distintos (4): 0x00, 0x7C, 0xE0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0xE0 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06F3D (28477): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06F3E (28478): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F3F (28479): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F40 (28480): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F41 (28481): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F42 (28482): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F43 (28483): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F44 (28484): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F45 (28485): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F46 (28486): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F47 (28487): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F48 (28488): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06F49 (28489): - Valores distintos (4): 0x00, 0x07, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0B -> 27 veces - 0x07 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06F4A (28490): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F4B (28491): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F4C (28492): - Valores distintos (4): 0x00, 0x7C, 0xE0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0xE0 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06F4D (28493): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06F4E (28494): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F4F (28495): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F50 (28496): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F51 (28497): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F52 (28498): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F53 (28499): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F54 (28500): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F55 (28501): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F56 (28502): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F57 (28503): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F58 (28504): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F59 (28505): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F5A (28506): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F5B (28507): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F5C (28508): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F5D (28509): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F5E (28510): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F5F (28511): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F60 (28512): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F61 (28513): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F62 (28514): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F63 (28515): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F64 (28516): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F65 (28517): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F66 (28518): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F67 (28519): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F68 (28520): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F69 (28521): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F6A (28522): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F6B (28523): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F6C (28524): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F6D (28525): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F6E (28526): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F6F (28527): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F70 (28528): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F71 (28529): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F72 (28530): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F73 (28531): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F74 (28532): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F75 (28533): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F76 (28534): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F77 (28535): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F78 (28536): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F79 (28537): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F7A (28538): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F7B (28539): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F7C (28540): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F7D (28541): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F7E (28542): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F7F (28543): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F80 (28544): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F81 (28545): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F82 (28546): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F83 (28547): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F84 (28548): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F85 (28549): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F86 (28550): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F87 (28551): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F88 (28552): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06F89 (28553): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06F8A (28554): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F8B (28555): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F8C (28556): - Valores distintos (3): 0x00, 0x7C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 48 veces - 0xFF -> 9 veces - -Offset 0x06F8D (28557): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06F8E (28558): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F8F (28559): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F90 (28560): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F91 (28561): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F92 (28562): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F93 (28563): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F94 (28564): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F95 (28565): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F96 (28566): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F97 (28567): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F98 (28568): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F99 (28569): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F9A (28570): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F9B (28571): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F9C (28572): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F9D (28573): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F9E (28574): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06F9F (28575): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA0 (28576): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA1 (28577): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA2 (28578): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA3 (28579): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA4 (28580): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA5 (28581): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA6 (28582): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA7 (28583): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FA8 (28584): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FA9 (28585): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x09 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FAA (28586): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FAB (28587): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FAC (28588): - Valores distintos (3): 0x00, 0x38, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x38 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FAD (28589): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FAE (28590): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FAF (28591): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FB0 (28592): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FB1 (28593): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FB2 (28594): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FB3 (28595): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FB4 (28596): - Valores distintos (3): 0x00, 0x5B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x5B -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FB5 (28597): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FB6 (28598): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FB7 (28599): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FB8 (28600): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FB9 (28601): - Valores distintos (4): 0x00, 0x08, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0B -> 27 veces - 0x08 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06FBA (28602): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FBB (28603): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FBC (28604): - Valores distintos (4): 0x00, 0x7C, 0xE5, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0xE5 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06FBD (28605): - Valores distintos (4): 0x00, 0x04, 0x06, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06FBE (28606): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FBF (28607): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FC0 (28608): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FC1 (28609): - Valores distintos (4): 0x00, 0x07, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0B -> 27 veces - 0x07 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06FC2 (28610): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FC3 (28611): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FC4 (28612): - Valores distintos (4): 0x00, 0x26, 0x7C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06FC5 (28613): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x06FC6 (28614): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FC7 (28615): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FC8 (28616): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FC9 (28617): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x09 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FCA (28618): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FCB (28619): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FCC (28620): - Valores distintos (3): 0x00, 0xAD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xAD -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FCD (28621): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x06FCE (28622): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FCF (28623): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD0 (28624): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD1 (28625): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD2 (28626): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD3 (28627): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD4 (28628): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD5 (28629): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD6 (28630): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD7 (28631): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD8 (28632): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FD9 (28633): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FDA (28634): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FDB (28635): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FDC (28636): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FDD (28637): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FDE (28638): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FDF (28639): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE0 (28640): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE1 (28641): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE2 (28642): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE3 (28643): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE4 (28644): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE5 (28645): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE6 (28646): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE7 (28647): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE8 (28648): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FE9 (28649): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FEA (28650): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FEB (28651): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FEC (28652): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FED (28653): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FEE (28654): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FEF (28655): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF0 (28656): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF1 (28657): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF2 (28658): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF3 (28659): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF4 (28660): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF5 (28661): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF6 (28662): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF7 (28663): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF8 (28664): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FF9 (28665): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FFA (28666): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FFB (28667): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FFC (28668): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FFD (28669): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FFE (28670): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x06FFF (28671): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07000 (28672): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07001 (28673): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07002 (28674): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07003 (28675): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07004 (28676): - Valores distintos (3): 0x00, 0x35, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x35 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07005 (28677): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07006 (28678): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07007 (28679): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07008 (28680): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07009 (28681): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x09 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0700A (28682): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0700B (28683): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0700C (28684): - Valores distintos (3): 0x00, 0x38, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x38 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0700D (28685): - Valores distintos (3): 0x00, 0x03, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x03 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0700E (28686): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0700F (28687): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07010 (28688): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07011 (28689): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07012 (28690): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07013 (28691): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07014 (28692): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07015 (28693): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07016 (28694): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07017 (28695): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07018 (28696): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07019 (28697): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0701A (28698): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0701B (28699): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0701C (28700): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0701D (28701): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0701E (28702): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0701F (28703): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07020 (28704): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07021 (28705): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07022 (28706): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07023 (28707): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07024 (28708): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07025 (28709): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07026 (28710): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07027 (28711): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07028 (28712): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07029 (28713): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0702A (28714): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0702B (28715): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0702C (28716): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0702D (28717): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0702E (28718): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0702F (28719): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07030 (28720): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07031 (28721): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07032 (28722): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07033 (28723): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07034 (28724): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07035 (28725): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07036 (28726): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07037 (28727): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07038 (28728): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07039 (28729): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0703A (28730): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0703B (28731): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0703C (28732): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0703D (28733): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0703E (28734): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0703F (28735): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07040 (28736): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07041 (28737): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07042 (28738): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07043 (28739): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07044 (28740): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07045 (28741): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07046 (28742): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07047 (28743): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07048 (28744): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07049 (28745): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x09 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0704A (28746): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0704B (28747): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0704C (28748): - Valores distintos (3): 0x00, 0xAD, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xAD -> 48 veces - 0xFF -> 9 veces - -Offset 0x0704D (28749): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0704E (28750): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0704F (28751): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07050 (28752): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07051 (28753): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07052 (28754): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07053 (28755): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07054 (28756): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07055 (28757): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07056 (28758): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07057 (28759): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07058 (28760): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07059 (28761): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0705A (28762): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0705B (28763): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0705C (28764): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0705D (28765): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0705E (28766): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0705F (28767): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07060 (28768): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07061 (28769): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07062 (28770): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07063 (28771): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07064 (28772): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07065 (28773): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07066 (28774): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07067 (28775): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07068 (28776): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07069 (28777): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0706A (28778): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0706B (28779): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0706C (28780): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0706D (28781): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0706E (28782): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0706F (28783): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07070 (28784): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07071 (28785): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07072 (28786): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07073 (28787): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07074 (28788): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07075 (28789): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07076 (28790): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07077 (28791): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07078 (28792): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07079 (28793): - Valores distintos (4): 0x00, 0x06, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0B -> 27 veces - 0x06 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0707A (28794): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0707B (28795): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0707C (28796): - Valores distintos (4): 0x00, 0x26, 0x7C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0707D (28797): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0707E (28798): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0707F (28799): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07080 (28800): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07081 (28801): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07082 (28802): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07083 (28803): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07084 (28804): - Valores distintos (4): 0x00, 0x26, 0x7C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07085 (28805): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07086 (28806): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07087 (28807): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07088 (28808): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07089 (28809): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x09 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0708A (28810): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0708B (28811): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0708C (28812): - Valores distintos (3): 0x00, 0xFA, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFA -> 48 veces - 0xFF -> 9 veces - -Offset 0x0708D (28813): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0708E (28814): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0708F (28815): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07090 (28816): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07091 (28817): - Valores distintos (4): 0x00, 0x03, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0B -> 27 veces - 0x03 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07092 (28818): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07093 (28819): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07094 (28820): - Valores distintos (4): 0x00, 0x26, 0x7C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07095 (28821): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07096 (28822): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07097 (28823): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07098 (28824): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07099 (28825): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0709A (28826): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0709B (28827): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0709C (28828): - Valores distintos (3): 0x00, 0x35, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x35 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0709D (28829): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0709E (28830): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0709F (28831): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070A0 (28832): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070A1 (28833): - Valores distintos (4): 0x00, 0x02, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0B -> 27 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070A2 (28834): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070A3 (28835): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070A4 (28836): - Valores distintos (4): 0x00, 0x26, 0x7C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070A5 (28837): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070A6 (28838): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070A7 (28839): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070A8 (28840): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070A9 (28841): - Valores distintos (3): 0x00, 0x09, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x09 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070AA (28842): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070AB (28843): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070AC (28844): - Valores distintos (3): 0x00, 0xFA, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFA -> 48 veces - 0xFF -> 9 veces - -Offset 0x070AD (28845): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070AE (28846): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070AF (28847): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070B0 (28848): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070B1 (28849): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070B2 (28850): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070B3 (28851): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070B4 (28852): - Valores distintos (4): 0x00, 0x26, 0x5B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x5B -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070B5 (28853): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070B6 (28854): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070B7 (28855): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070B8 (28856): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070B9 (28857): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070BA (28858): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070BB (28859): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070BC (28860): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070BD (28861): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070BE (28862): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070BF (28863): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C0 (28864): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C1 (28865): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C2 (28866): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C3 (28867): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C4 (28868): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C5 (28869): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C6 (28870): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C7 (28871): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C8 (28872): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070C9 (28873): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070CA (28874): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070CB (28875): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070CC (28876): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070CD (28877): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070CE (28878): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070CF (28879): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070D0 (28880): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070D1 (28881): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070D2 (28882): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070D3 (28883): - Valores distintos (4): 0x00, 0x0A, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0A -> 27 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x070D4 (28884): - Valores distintos (4): 0x00, 0x7C, 0xA6, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0xA6 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070D5 (28885): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070D6 (28886): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070D7 (28887): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070D8 (28888): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070D9 (28889): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070DA (28890): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070DB (28891): - Valores distintos (4): 0x00, 0x01, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 27 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x070DC (28892): - Valores distintos (4): 0x00, 0x7C, 0xE0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0xE0 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070DD (28893): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070DE (28894): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070DF (28895): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070E0 (28896): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070E1 (28897): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x02 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070E2 (28898): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070E3 (28899): - Valores distintos (4): 0x00, 0x05, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 27 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x070E4 (28900): - Valores distintos (4): 0x00, 0x7C, 0xBF, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0xBF -> 21 veces - 0xFF -> 9 veces - -Offset 0x070E5 (28901): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070E6 (28902): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070E7 (28903): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070E8 (28904): - Valores distintos (4): 0x00, 0x0B, 0x0C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x0B -> 27 veces - 0x0C -> 21 veces - 0xFF -> 9 veces - -Offset 0x070E9 (28905): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070EA (28906): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070EB (28907): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 198 veces - 0x05 -> 27 veces - 0xFF -> 9 veces - -Offset 0x070EC (28908): - Valores distintos (4): 0x00, 0x26, 0x7C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070ED (28909): - Valores distintos (4): 0x00, 0x04, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 27 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070EE (28910): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070EF (28911): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070F0 (28912): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070F1 (28913): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070F2 (28914): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x01 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070F3 (28915): - Valores distintos (4): 0x00, 0x05, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x05 -> 27 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x070F4 (28916): - Valores distintos (4): 0x00, 0x7C, 0xE0, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7C -> 27 veces - 0xE0 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070F5 (28917): - Valores distintos (3): 0x00, 0x04, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x04 -> 48 veces - 0xFF -> 9 veces - -Offset 0x070F6 (28918): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070F7 (28919): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070F8 (28920): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070F9 (28921): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070FA (28922): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070FB (28923): - Valores distintos (3): 0x00, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x070FC (28924): - Valores distintos (3): 0x00, 0xA1, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0xA1 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070FD (28925): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x070FE (28926): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x070FF (28927): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07100 (28928): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07101 (28929): - Valores distintos (3): 0x00, 0x02, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x02 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07102 (28930): - Valores distintos (3): 0x00, 0x01, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x01 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07103 (28931): - Valores distintos (3): 0x00, 0x0B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x0B -> 21 veces - 0xFF -> 9 veces - -Offset 0x07104 (28932): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x6C -> 21 veces - 0xFF -> 9 veces - -Offset 0x07105 (28933): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07106 (28934): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07107 (28935): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07108 (28936): - Valores distintos (3): 0x00, 0x07, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x07 -> 21 veces - 0xFF -> 9 veces - -Offset 0x07109 (28937): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0710A (28938): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0710B (28939): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0710C (28940): - Valores distintos (3): 0x00, 0x26, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x26 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0710D (28941): - Valores distintos (3): 0x00, 0x05, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 204 veces - 0x05 -> 21 veces - 0xFF -> 9 veces - -Offset 0x0710E (28942): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0710F (28943): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07110 (28944): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07111 (28945): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07112 (28946): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07113 (28947): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07114 (28948): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07115 (28949): - Valores distintos (3): 0x00, 0x53, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x53 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07116 (28950): - Valores distintos (3): 0x00, 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x65 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07117 (28951): - Valores distintos (3): 0x00, 0x72, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x72 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07118 (28952): - Valores distintos (3): 0x00, 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6F -> 48 veces - 0xFF -> 9 veces - -Offset 0x07119 (28953): - Valores distintos (3): 0x00, 0x77, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x77 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0711A (28954): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0711B (28955): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0711C (28956): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0711D (28957): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0711E (28958): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0711F (28959): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07120 (28960): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07121 (28961): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07122 (28962): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07123 (28963): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07124 (28964): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07125 (28965): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07126 (28966): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07127 (28967): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07128 (28968): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07129 (28969): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0712A (28970): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0712B (28971): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0712C (28972): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0712D (28973): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0712E (28974): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0712F (28975): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07130 (28976): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07131 (28977): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07132 (28978): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07133 (28979): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07134 (28980): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07135 (28981): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07136 (28982): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07137 (28983): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07138 (28984): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07139 (28985): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0713A (28986): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0713B (28987): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0713C (28988): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0713D (28989): - Valores distintos (3): 0x00, 0x50, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x50 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0713E (28990): - Valores distintos (3): 0x00, 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6F -> 48 veces - 0xFF -> 9 veces - -Offset 0x0713F (28991): - Valores distintos (3): 0x00, 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6F -> 48 veces - 0xFF -> 9 veces - -Offset 0x07140 (28992): - Valores distintos (3): 0x00, 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x63 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07141 (28993): - Valores distintos (3): 0x00, 0x68, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x68 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07142 (28994): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07143 (28995): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07144 (28996): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07145 (28997): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07146 (28998): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07147 (28999): - Valores distintos (3): 0x00, 0x43, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x43 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07148 (29000): - Valores distintos (3): 0x00, 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6F -> 48 veces - 0xFF -> 9 veces - -Offset 0x07149 (29001): - Valores distintos (3): 0x00, 0x6F, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6F -> 48 veces - 0xFF -> 9 veces - -Offset 0x0714A (29002): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0714B (29003): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0714C (29004): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0714D (29005): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0714E (29006): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0714F (29007): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07150 (29008): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07151 (29009): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07152 (29010): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07153 (29011): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07154 (29012): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07155 (29013): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07156 (29014): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07157 (29015): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07158 (29016): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07159 (29017): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0715A (29018): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0715B (29019): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0715C (29020): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0715D (29021): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0715E (29022): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0715F (29023): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07160 (29024): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07161 (29025): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07162 (29026): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07163 (29027): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07164 (29028): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07165 (29029): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07166 (29030): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07167 (29031): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07168 (29032): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07169 (29033): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0716A (29034): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0716B (29035): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0716C (29036): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0716D (29037): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0716E (29038): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0716F (29039): - Valores distintos (3): 0x00, 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4B -> 48 veces - 0xFF -> 9 veces - -Offset 0x07170 (29040): - Valores distintos (3): 0x00, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x61 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07171 (29041): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6C -> 48 veces - 0xFF -> 9 veces - -Offset 0x07172 (29042): - Valores distintos (3): 0x00, 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x65 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07173 (29043): - Valores distintos (3): 0x00, 0x6E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6E -> 48 veces - 0xFF -> 9 veces - -Offset 0x07174 (29044): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07175 (29045): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07176 (29046): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07177 (29047): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07178 (29048): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07179 (29049): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0717A (29050): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0717B (29051): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0717C (29052): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0717D (29053): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0717E (29054): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0717F (29055): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07180 (29056): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07181 (29057): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07182 (29058): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07183 (29059): - Valores distintos (3): 0x00, 0x50, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x50 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07184 (29060): - Valores distintos (3): 0x00, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x69 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07185 (29061): - Valores distintos (3): 0x00, 0x6E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6E -> 48 veces - 0xFF -> 9 veces - -Offset 0x07186 (29062): - Valores distintos (3): 0x00, 0x6B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6B -> 48 veces - 0xFF -> 9 veces - -Offset 0x07187 (29063): - Valores distintos (3): 0x00, 0x79, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x79 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07188 (29064): - Valores distintos (3): 0x00, 0x53, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x53 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07189 (29065): - Valores distintos (3): 0x00, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x69 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0718A (29066): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6C -> 48 veces - 0xFF -> 9 veces - -Offset 0x0718B (29067): - Valores distintos (3): 0x00, 0x76, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x76 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0718C (29068): - Valores distintos (3): 0x00, 0x79, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x79 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0718D (29069): - Valores distintos (3): 0x00, 0x53, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x53 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0718E (29070): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0718F (29071): - Valores distintos (3): 0x00, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x69 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07190 (29072): - Valores distintos (3): 0x00, 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x63 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07191 (29073): - Valores distintos (3): 0x00, 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x65 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07192 (29074): - Valores distintos (3): 0x00, 0x4D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4D -> 48 veces - 0xFF -> 9 veces - -Offset 0x07193 (29075): - Valores distintos (3): 0x00, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x61 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07194 (29076): - Valores distintos (3): 0x00, 0x72, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x72 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07195 (29077): - Valores distintos (3): 0x00, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x69 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07196 (29078): - Valores distintos (3): 0x00, 0x6E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6E -> 48 veces - 0xFF -> 9 veces - -Offset 0x07197 (29079): - Valores distintos (3): 0x00, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x41 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07198 (29080): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6C -> 48 veces - 0xFF -> 9 veces - -Offset 0x07199 (29081): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0719A (29082): - Valores distintos (3): 0x00, 0x68, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x68 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0719B (29083): - Valores distintos (3): 0x00, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x61 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0719C (29084): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0719D (29085): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0719E (29086): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0719F (29087): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A0 (29088): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A1 (29089): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A2 (29090): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A3 (29091): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A4 (29092): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A5 (29093): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A6 (29094): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A7 (29095): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A8 (29096): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071A9 (29097): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071AA (29098): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071AB (29099): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071AC (29100): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071AD (29101): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071AE (29102): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071AF (29103): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B0 (29104): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B1 (29105): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B2 (29106): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B3 (29107): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B4 (29108): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B5 (29109): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B6 (29110): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B7 (29111): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B8 (29112): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071B9 (29113): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071BA (29114): - Valores distintos (3): 0x00, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x41 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071BB (29115): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071BC (29116): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071BD (29117): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6C -> 48 veces - 0xFF -> 9 veces - -Offset 0x071BE (29118): - Valores distintos (3): 0x00, 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x65 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071BF (29119): - Valores distintos (3): 0x00, 0x54, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x54 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071C0 (29120): - Valores distintos (3): 0x00, 0x75, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x75 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071C1 (29121): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6C -> 48 veces - 0xFF -> 9 veces - -Offset 0x071C2 (29122): - Valores distintos (3): 0x00, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x69 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071C3 (29123): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071C4 (29124): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071C5 (29125): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071C6 (29126): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071C7 (29127): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071C8 (29128): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071C9 (29129): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071CA (29130): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071CB (29131): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071CC (29132): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071CD (29133): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071CE (29134): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071CF (29135): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D0 (29136): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D1 (29137): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D2 (29138): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D3 (29139): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D4 (29140): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D5 (29141): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D6 (29142): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D7 (29143): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D8 (29144): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071D9 (29145): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071DA (29146): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071DB (29147): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071DC (29148): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071DD (29149): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071DE (29150): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071DF (29151): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071E0 (29152): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071E1 (29153): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071E2 (29154): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071E3 (29155): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071E4 (29156): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071E5 (29157): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071E6 (29158): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071E7 (29159): - Valores distintos (3): 0x00, 0x53, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x53 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071E8 (29160): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071E9 (29161): - Valores distintos (3): 0x00, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x69 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071EA (29162): - Valores distintos (3): 0x00, 0x74, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x74 -> 48 veces - 0xFF -> 9 veces - -Offset 0x071EB (29163): - Valores distintos (3): 0x00, 0x7A, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x7A -> 48 veces - 0xFF -> 9 veces - -Offset 0x071EC (29164): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071ED (29165): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071EE (29166): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071EF (29167): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F0 (29168): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F1 (29169): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F2 (29170): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F3 (29171): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F4 (29172): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F5 (29173): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F6 (29174): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F7 (29175): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F8 (29176): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071F9 (29177): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071FA (29178): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071FB (29179): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071FC (29180): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071FD (29181): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071FE (29182): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x071FF (29183): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07200 (29184): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07201 (29185): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07202 (29186): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07203 (29187): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07204 (29188): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07205 (29189): - Valores distintos (3): 0x00, 0x57, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x57 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07206 (29190): - Valores distintos (3): 0x00, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x61 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07207 (29191): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6C -> 48 veces - 0xFF -> 9 veces - -Offset 0x07208 (29192): - Valores distintos (3): 0x00, 0x64, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x64 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07209 (29193): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0720A (29194): - Valores distintos (3): 0x00, 0x52, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x52 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0720B (29195): - Valores distintos (3): 0x00, 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x65 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0720C (29196): - Valores distintos (3): 0x00, 0x62, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x62 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0720D (29197): - Valores distintos (3): 0x00, 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x65 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0720E (29198): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0720F (29199): - Valores distintos (3): 0x00, 0x59, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x59 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07210 (29200): - Valores distintos (3): 0x00, 0x69, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x69 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07211 (29201): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07212 (29202): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x07213 (29203): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x07214 (29204): - Valores distintos (3): 0x00, 0x53, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x53 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07215 (29205): - Valores distintos (3): 0x00, 0x63, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x63 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07216 (29206): - Valores distintos (3): 0x00, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x61 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07217 (29207): - Valores distintos (3): 0x00, 0x74, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x74 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07218 (29208): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x07219 (29209): - Valores distintos (3): 0x00, 0x50, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x50 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0721A (29210): - Valores distintos (3): 0x00, 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x66 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0721B (29211): - Valores distintos (3): 0x00, 0x61, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x61 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0721C (29212): - Valores distintos (3): 0x00, 0x75, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x75 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0721D (29213): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0721E (29214): - Valores distintos (3): 0x00, 0x44, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x44 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0721F (29215): - Valores distintos (3): 0x00, 0x72, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x72 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07220 (29216): - Valores distintos (3): 0x00, 0x3E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3E -> 48 veces - 0xFF -> 9 veces - -Offset 0x07221 (29217): - Valores distintos (3): 0x00, 0x4B, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4B -> 48 veces - 0xFF -> 9 veces - -Offset 0x07222 (29218): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x07223 (29219): - Valores distintos (3): 0x00, 0x41, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x41 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07224 (29220): - Valores distintos (3): 0x00, 0x70, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x70 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07225 (29221): - Valores distintos (3): 0x00, 0x66, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x66 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07226 (29222): - Valores distintos (3): 0x00, 0x65, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x65 -> 48 veces - 0xFF -> 9 veces - -Offset 0x07227 (29223): - Valores distintos (3): 0x00, 0x6C, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x6C -> 48 veces - 0xFF -> 9 veces - -Offset 0x07228 (29224): - Valores distintos (3): 0x00, 0x4D, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x4D -> 48 veces - 0xFF -> 9 veces - -Offset 0x07229 (29225): - Valores distintos (3): 0x00, 0x72, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x72 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0722A (29226): - Valores distintos (3): 0x00, 0x3E, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x3E -> 48 veces - 0xFF -> 9 veces - -Offset 0x0722B (29227): - Valores distintos (3): 0x00, 0x51, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0x51 -> 48 veces - 0xFF -> 9 veces - -Offset 0x0722C (29228): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 177 veces - 0xFF -> 57 veces - -Offset 0x0722D (29229): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0722E (29230): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0722F (29231): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07230 (29232): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07231 (29233): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07232 (29234): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07233 (29235): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07234 (29236): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07235 (29237): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07236 (29238): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07237 (29239): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07238 (29240): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07239 (29241): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0723A (29242): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0723B (29243): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0723C (29244): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0723D (29245): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0723E (29246): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0723F (29247): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07240 (29248): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07241 (29249): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07242 (29250): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07243 (29251): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07244 (29252): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07245 (29253): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07246 (29254): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07247 (29255): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07248 (29256): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07249 (29257): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0724A (29258): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0724B (29259): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0724C (29260): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0724D (29261): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0724E (29262): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0724F (29263): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07250 (29264): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07251 (29265): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07252 (29266): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07253 (29267): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07254 (29268): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07255 (29269): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07256 (29270): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07257 (29271): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07258 (29272): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07259 (29273): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0725A (29274): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0725B (29275): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0725C (29276): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0725D (29277): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0725E (29278): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0725F (29279): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07260 (29280): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07261 (29281): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07262 (29282): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07263 (29283): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07264 (29284): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07265 (29285): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07266 (29286): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07267 (29287): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07268 (29288): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07269 (29289): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0726A (29290): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0726B (29291): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0726C (29292): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0726D (29293): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0726E (29294): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0726F (29295): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07270 (29296): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07271 (29297): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07272 (29298): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07273 (29299): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07274 (29300): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07275 (29301): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07276 (29302): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07277 (29303): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07278 (29304): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07279 (29305): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0727A (29306): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0727B (29307): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0727C (29308): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0727D (29309): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0727E (29310): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0727F (29311): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07280 (29312): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07281 (29313): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07282 (29314): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07283 (29315): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07284 (29316): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07285 (29317): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07286 (29318): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07287 (29319): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07288 (29320): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07289 (29321): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0728A (29322): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0728B (29323): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0728C (29324): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0728D (29325): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0728E (29326): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0728F (29327): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07290 (29328): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07291 (29329): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07292 (29330): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07293 (29331): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07294 (29332): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07295 (29333): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07296 (29334): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07297 (29335): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07298 (29336): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x07299 (29337): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0729A (29338): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0729B (29339): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0729C (29340): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0729D (29341): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0729E (29342): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x0729F (29343): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A0 (29344): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A1 (29345): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A2 (29346): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A3 (29347): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A4 (29348): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A5 (29349): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A6 (29350): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A7 (29351): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A8 (29352): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072A9 (29353): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072AA (29354): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072AB (29355): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072AC (29356): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072AD (29357): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072AE (29358): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072AF (29359): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B0 (29360): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B1 (29361): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B2 (29362): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B3 (29363): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B4 (29364): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B5 (29365): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B6 (29366): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B7 (29367): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B8 (29368): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072B9 (29369): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072BA (29370): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072BB (29371): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072BC (29372): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072BD (29373): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072BE (29374): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072BF (29375): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C0 (29376): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C1 (29377): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C2 (29378): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C3 (29379): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C4 (29380): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C5 (29381): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C6 (29382): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C7 (29383): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C8 (29384): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072C9 (29385): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072CA (29386): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072CB (29387): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072CC (29388): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072CD (29389): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072CE (29390): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072CF (29391): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D0 (29392): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D1 (29393): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D2 (29394): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D3 (29395): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D4 (29396): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D5 (29397): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D6 (29398): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D7 (29399): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D8 (29400): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072D9 (29401): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072DA (29402): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072DB (29403): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072DC (29404): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072DD (29405): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072DE (29406): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072DF (29407): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E0 (29408): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E1 (29409): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E2 (29410): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E3 (29411): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E4 (29412): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E5 (29413): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E6 (29414): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E7 (29415): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E8 (29416): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072E9 (29417): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072EA (29418): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072EB (29419): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072EC (29420): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072ED (29421): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072EE (29422): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072EF (29423): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F0 (29424): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F1 (29425): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F2 (29426): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F3 (29427): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F4 (29428): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F5 (29429): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F6 (29430): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F7 (29431): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F8 (29432): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072F9 (29433): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072FA (29434): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072FB (29435): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072FC (29436): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072FD (29437): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072FE (29438): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - -Offset 0x072FF (29439): - Valores distintos (2): 0x00, 0xFF - Clasificación: small_state - Más frecuentes: - 0x00 -> 225 veces - 0xFF -> 9 veces - diff --git a/set_contador_armarios.py b/set_contador_armarios.py new file mode 100644 index 0000000..90e4d25 --- /dev/null +++ b/set_contador_armarios.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +import sys + +# Rango del checksum +desp = 0x2000 +numBytes = 0x2000 +firstByte = desp + 0x200 +lastByte = desp + numBytes - 1 +checksum1 = desp + 0x270 +checksum2 = desp + 0x271 + +# Offset del contador de armarios +CONTADOR = 0x0295C + +def calc_checksum(buffer): + total = 0 + for i in range(firstByte, lastByte + 1): + if i not in (checksum1, checksum2): + total += buffer[i] + total += 3328 + buffer[checksum1] = total % 256 + buffer[checksum2] = (total >> 8) % 256 + +if len(sys.argv) != 3: + print("Uso: python3 set_contador_armarios.py save_in.srm save_out.srm") + sys.exit(1) + +infile = sys.argv[1] +outfile = sys.argv[2] + +with open(infile, "rb") as f: + buf = bytearray(f.read()) + +# Poner el contador a 0x80 +buf[CONTADOR] = 0x4F + +# Recalcular checksum +calc_checksum(buf) + +with open(outfile, "wb") as f: + f.write(buf) + +print("Hecho:", outfile)