t

u

g

a

s

95%-Grenze ->

120 x laplacewürfeln

\text{In jeder der 422 Zeilen des Kalkulationsblattes werden 120 Würfe eines Laplacewürfels}\
\text{simuliert und ausgezählt.}\
\text{Die Abweichungen der Häufigkeiten vom erwarteten Wert 20 werden gemessen durch}\
\colorbox{White}
{
\begin{array}{ll} 
t = \sum \frac{(x_i-20)^2}{20} & \text{(Spalte H)} \ 
s=\sum |x_i-20|  & \text{(Spalte I)} \ 
u=max(x_i)-min(x_i)  & \text{(Spalte J)}\ 
g=max(|x_i-20|) & \text{(Spalte K) } \ 
 a=Anzahl(x_i<11)+Anzahl(x_i>29) & \text{(Spalte L)} \ 

\end{array} }

\ \
\text{Im Bereich H2:L2 liest man ab, welche “Benchmarks” die genannten Abweichungsmaße}\ 
\text{nur selten (in weniger als 5\;\% aller Fälle) überschreiten.}\
\text{Wenn bei einem realen 120-er Würfelversuch diese Benchmarks erreicht oder überschritten}\
\text{werden, sind Zweifel daran angebracht, dass die Gleichverteilung ein gutes Modell für den}\
\text{Würfel ist.}\ \ \

\text{Mit F9 (ctrl R, cmd R, Schaltfläche “Simulation”) startet man eine neue Simulation.}

Info

Simulation

A29 = Sequence(Random[1, 6], k, 1, 120)
A101 = Sequence(Random[1, 6], k, 1, 120)
B29 = CountIf(x ≟ 1, A29)
G29 = CountIf(x ≟ 6, A29)
F29 = CountIf(x ≟ 5, A29)
E29 = CountIf(x ≟ 4, A29)
D29 = CountIf(x ≟ 3, A29)
C29 = CountIf(x ≟ 2, A29)
A27 = Sequence(Random[1, 6], k, 1, 120)
A26 = Sequence(Random[1, 6], k, 1, 120)
A25 = Sequence(Random[1, 6], k, 1, 120)
A24 = Sequence(Random[1, 6], k, 1, 120)
A23 = Sequence(Random[1, 6], k, 1, 120)
A22 = Sequence(Random[1, 6], k, 1, 120)
A21 = Sequence(Random[1, 6], k, 1, 120)
A20 = Sequence(Random[1, 6], k, 1, 120)
A19 = Sequence(Random[1, 6], k, 1, 120)
A18 = Sequence(Random[1, 6], k, 1, 120)
A17 = Sequence(Random[1, 6], k, 1, 120)
A16 = Sequence(Random[1, 6], k, 1, 120)
A15 = Sequence(Random[1, 6], k, 1, 120)
A14 = Sequence(Random[1, 6], k, 1, 120)
A13 = Sequence(Random[1, 6], k, 1, 120)
A12 = Sequence(Random[1, 6], k, 1, 120)
A11 = Sequence(Random[1, 6], k, 1, 120)
A10 = Sequence(Random[1, 6], k, 1, 120)
A9 = Sequence(Random[1, 6], k, 1, 120)
A8 = Sequence(Random[1, 6], k, 1, 120)
A7 = Sequence(Random[1, 6], k, 1, 120)
A6 = Sequence(Random[1, 6], k, 1, 120)
A5 = Sequence(Random[1, 6], k, 1, 120)
A4 = Sequence(Random[1, 6], k, 1, 120)
A3 = Sequence(Random[1, 6], k, 1, 120)
G27 = CountIf(x ≟ 6, A27)
F27 = CountIf(x ≟ 5, A27)
E27 = CountIf(x ≟ 4, A27)
D27 = CountIf(x ≟ 3, A27)
B27 = CountIf(x ≟ 1, A27)
G26 = CountIf(x ≟ 6, A26)
F26 = CountIf(x ≟ 5, A26)
E26 = CountIf(x ≟ 4, A26)
D26 = CountIf(x ≟ 3, A26)
B26 = CountIf(x ≟ 1, A26)
G25 = CountIf(x ≟ 6, A25)
F25 = CountIf(x ≟ 5, A25)
E25 = CountIf(x ≟ 4, A25)
D25 = CountIf(x ≟ 3, A25)
B25 = CountIf(x ≟ 1, A25)
G24 = CountIf(x ≟ 6, A24)
F24 = CountIf(x ≟ 5, A24)
E24 = CountIf(x ≟ 4, A24)
D24 = CountIf(x ≟ 3, A24)
B24 = CountIf(x ≟ 1, A24)
G23 = CountIf(x ≟ 6, A23)
F23 = CountIf(x ≟ 5, A23)
E23 = CountIf(x ≟ 4, A23)
D23 = CountIf(x ≟ 3, A23)
B23 = CountIf(x ≟ 1, A23)
G22 = CountIf(x ≟ 6, A22)
F22 = CountIf(x ≟ 5, A22)
E22 = CountIf(x ≟ 4, A22)
D22 = CountIf(x ≟ 3, A22)
B22 = CountIf(x ≟ 1, A22)
G19 = CountIf(x ≟ 6, A19)
F19 = CountIf(x ≟ 5, A19)
E19 = CountIf(x ≟ 4, A19)
D19 = CountIf(x ≟ 3, A19)
B19 = CountIf(x ≟ 1, A19)
G18 = CountIf(x ≟ 6, A18)
F18 = CountIf(x ≟ 5, A18)
E18 = CountIf(x ≟ 4, A18)
D18 = CountIf(x ≟ 3, A18)
B18 = CountIf(x ≟ 1, A18)
G17 = CountIf(x ≟ 6, A17)
F17 = CountIf(x ≟ 5, A17)
E17 = CountIf(x ≟ 4, A17)
D17 = CountIf(x ≟ 3, A17)
B17 = CountIf(x ≟ 1, A17)
G16 = CountIf(x ≟ 6, A16)
F16 = CountIf(x ≟ 5, A16)
E16 = CountIf(x ≟ 4, A16)
D16 = CountIf(x ≟ 3, A16)
B16 = CountIf(x ≟ 1, A16)
G15 = CountIf(x ≟ 6, A15)
F15 = CountIf(x ≟ 5, A15)
E15 = CountIf(x ≟ 4, A15)
D15 = CountIf(x ≟ 3, A15)
B15 = CountIf(x ≟ 1, A15)
G14 = CountIf(x ≟ 6, A14)
F14 = CountIf(x ≟ 5, A14)
E14 = CountIf(x ≟ 4, A14)
D14 = CountIf(x ≟ 3, A14)
B14 = CountIf(x ≟ 1, A14)
G13 = CountIf(x ≟ 6, A13)
F13 = CountIf(x ≟ 5, A13)
E13 = CountIf(x ≟ 4, A13)
D13 = CountIf(x ≟ 3, A13)
B13 = CountIf(x ≟ 1, A13)
G12 = CountIf(x ≟ 6, A12)
F12 = CountIf(x ≟ 5, A12)
E12 = CountIf(x ≟ 4, A12)
D12 = CountIf(x ≟ 3, A12)
B12 = CountIf(x ≟ 1, A12)
G11 = CountIf(x ≟ 6, A11)
F11 = CountIf(x ≟ 5, A11)
E11 = CountIf(x ≟ 4, A11)
D11 = CountIf(x ≟ 3, A11)
B11 = CountIf(x ≟ 1, A11)
G10 = CountIf(x ≟ 6, A10)
F10 = CountIf(x ≟ 5, A10)
E10 = CountIf(x ≟ 4, A10)
D10 = CountIf(x ≟ 3, A10)
B10 = CountIf(x ≟ 1, A10)
G9 = CountIf(x ≟ 6, A9)
F9 = CountIf(x ≟ 5, A9)
E9 = CountIf(x ≟ 4, A9)
D9 = CountIf(x ≟ 3, A9)
B9 = CountIf(x ≟ 1, A9)
G8 = CountIf(x ≟ 6, A8)
F8 = CountIf(x ≟ 5, A8)
E8 = CountIf(x ≟ 4, A8)
D8 = CountIf(x ≟ 3, A8)
B8 = CountIf(x ≟ 1, A8)
G7 = CountIf(x ≟ 6, A7)
F7 = CountIf(x ≟ 5, A7)
E7 = CountIf(x ≟ 4, A7)
D7 = CountIf(x ≟ 3, A7)
B7 = CountIf(x ≟ 1, A7)
G6 = CountIf(x ≟ 6, A6)
F6 = CountIf(x ≟ 5, A6)
E6 = CountIf(x ≟ 4, A6)
D6 = CountIf(x ≟ 3, A6)
B6 = CountIf(x ≟ 1, A6)
G5 = CountIf(x ≟ 6, A5)
F5 = CountIf(x ≟ 5, A5)
E5 = CountIf(x ≟ 4, A5)
D5 = CountIf(x ≟ 3, A5)
B5 = CountIf(x ≟ 1, A5)
B4 = CountIf(x ≟ 1, A4)
B3 = CountIf(x ≟ 1, A3)
D3 = CountIf(x ≟ 3, A3)
E3 = CountIf(x ≟ 4, A3)
F3 = CountIf(x ≟ 5, A3)
G3 = CountIf(x ≟ 6, A3)
E1001 = Sum(E2:E1001)
C3 = CountIf(x ≟ 2, A3)
H3_1: (B3 - 20)^(2) / 20 + (C3 - 20)^(2) / 20 + (D3 - 20)^(2) / 20 + (E3 - 20)^(2) / 20 + (F3 - 20)^(2) / 20 + (G3 - 20)^(2) / 20
H3: (B3 - 20)^(2) / 20 + (C3 - 20)^(2) / 20 + (D3 - 20)^(2) / 20 + (E3 - 20)^(2) / 20 + (F3 - 20)^(2) / 20 + (G3 - 20)^(2) / 20
F1_2 = 0
A28 = Sequence(Random[1, 6], k, 1, 120)
L3: CountIf[x < 11, B3:G3] + CountIf[x > 29, B3:G3]
L4: CountIf[x < 11, B4:G4] + CountIf[x > 29, B4:G4]
L5: CountIf[x < 11, B5:G5] + CountIf[x > 29, B5:G5]
L6: CountIf[x < 11, B6:G6] + CountIf[x > 29, B6:G6]
L7: CountIf[x < 11, B7:G7] + CountIf[x > 29, B7:G7]
L8: CountIf[x < 11, B8:G8] + CountIf[x > 29, B8:G8]
L9: CountIf[x < 11, B9:G9] + CountIf[x > 29, B9:G9]
L10: CountIf[x < 11, B10:G10] + CountIf[x > 29, B10:G10]
L11: CountIf[x < 11, B11:G11] + CountIf[x > 29, B11:G11]
L12: CountIf[x < 11, B12:G12] + CountIf[x > 29, B12:G12]
L13: CountIf[x < 11, B13:G13] + CountIf[x > 29, B13:G13]
B20 = CountIf(x ≟ 1, A20)
D20 = CountIf(x ≟ 3, A20)
E20 = CountIf(x ≟ 4, A20)
F20 = CountIf(x ≟ 5, A20)
G20 = CountIf(x ≟ 6, A20)
B21 = CountIf(x ≟ 1, A21)
D21 = CountIf(x ≟ 3, A21)
E21 = CountIf(x ≟ 4, A21)
F21 = CountIf(x ≟ 5, A21)
G21 = CountIf(x ≟ 6, A21)
C20 = CountIf(x ≟ 2, A20)
H20: (B20 - 20)^(2) / 20 + (C20 - 20)^(2) / 20 + (D20 - 20)^(2) / 20 + (E20 - 20)^(2) / 20 + (F20 - 20)^(2) / 20 + (G20 - 20)^(2) / 20
C21 = CountIf(x ≟ 2, A21)
H21: (B21 - 20)^(2) / 20 + (C21 - 20)^(2) / 20 + (D21 - 20)^(2) / 20 + (E21 - 20)^(2) / 20 + (F21 - 20)^(2) / 20 + (G21 - 20)^(2) / 20
I3 = Sum(abs(B3:G3 - 20))
I4 = Sum(abs(B4:G4 - 20))
I5 = Sum(abs(B5:G5 - 20))
I6 = Sum(abs(B6:G6 - 20))
I7 = Sum(abs(B7:G7 - 20))
I8 = Sum(abs(B8:G8 - 20))
I9 = Sum(abs(B9:G9 - 20))
I10 = Sum(abs(B10:G10 - 20))
I11 = Sum(abs(B11:G11 - 20))
I12 = Sum(abs(B12:G12 - 20))
I13 = Sum(abs(B13:G13 - 20))
I14 = Sum(abs(B14:G14 - 20))
I15 = Sum(abs(B15:G15 - 20))
I16 = Sum(abs(B16:G16 - 20))
I17 = Sum(abs(B17:G17 - 20))
I18 = Sum(abs(B18:G18 - 20))
I19 = Sum(abs(B19:G19 - 20))
I20 = Sum(abs(B20:G20 - 20))
I21 = Sum(abs(B21:G21 - 20))
I22 = Sum(abs(B22:G22 - 20))
I23 = Sum(abs(B23:G23 - 20))
I24 = Sum(abs(B24:G24 - 20))
I25 = Sum(abs(B25:G25 - 20))
I26 = Sum(abs(B26:G26 - 20))
I27 = Sum(abs(B27:G27 - 20))
I28 = Sum(abs(B28:G28 - 20))
J3: Max[B3:G3] - Min[B3:G3]
J4: Max[B4:G4] - Min[B4:G4]
J5: Max[B5:G5] - Min[B5:G5]
J6: Max[B6:G6] - Min[B6:G6]
J7: Max[B7:G7] - Min[B7:G7]
J8: Max[B8:G8] - Min[B8:G8]
J9: Max[B9:G9] - Min[B9:G9]
J10: Max[B10:G10] - Min[B10:G10]
J11: Max[B11:G11] - Min[B11:G11]
J12: Max[B12:G12] - Min[B12:G12]
J13: Max[B13:G13] - Min[B13:G13]
J14: Max[B14:G14] - Min[B14:G14]
J15: Max[B15:G15] - Min[B15:G15]
J16: Max[B16:G16] - Min[B16:G16]
J17: Max[B17:G17] - Min[B17:G17]
J18: Max[B18:G18] - Min[B18:G18]
J19: Max[B19:G19] - Min[B19:G19]
J20: Max[B20:G20] - Min[B20:G20]
J21: Max[B21:G21] - Min[B21:G21]
J22: Max[B22:G22] - Min[B22:G22]
J23: Max[B23:G23] - Min[B23:G23]
J24: Max[B24:G24] - Min[B24:G24]
J25: Max[B25:G25] - Min[B25:G25]
J26: Max[B26:G26] - Min[B26:G26]
J27: Max[B27:G27] - Min[B27:G27]
J28: Max[B28:G28] - Min[B28:G28]
K3 = Max(abs(B3:G3 - 20))
K4 = Max(abs(B4:G4 - 20))
K5 = Max(abs(B5:G5 - 20))
K6 = Max(abs(B6:G6 - 20))
K7 = Max(abs(B7:G7 - 20))
K8 = Max(abs(B8:G8 - 20))
K9 = Max(abs(B9:G9 - 20))
K10 = Max(abs(B10:G10 - 20))
K11 = Max(abs(B11:G11 - 20))
K12 = Max(abs(B12:G12 - 20))
K13 = Max(abs(B13:G13 - 20))
K14 = Max(abs(B14:G14 - 20))
K15 = Max(abs(B15:G15 - 20))
K16 = Max(abs(B16:G16 - 20))
K17 = Max(abs(B17:G17 - 20))
K18 = Max(abs(B18:G18 - 20))
K19 = Max(abs(B19:G19 - 20))
K20 = Max(abs(B20:G20 - 20))
K21 = Max(abs(B21:G21 - 20))
K22 = Max(abs(B22:G22 - 20))
K23 = Max(abs(B23:G23 - 20))
K24 = Max(abs(B24:G24 - 20))
K25 = Max(abs(B25:G25 - 20))
K26 = Max(abs(B26:G26 - 20))
K27 = Max(abs(B27:G27 - 20))
K28 = Max(abs(B28:G28 - 20))
L14: CountIf[x < 11, B14:G14] + CountIf[x > 29, B14:G14]
L15: CountIf[x < 11, B15:G15] + CountIf[x > 29, B15:G15]
L16: CountIf[x < 11, B16:G16] + CountIf[x > 29, B16:G16]
L17: CountIf[x < 11, B17:G17] + CountIf[x > 29, B17:G17]
L18: CountIf[x < 11, B18:G18] + CountIf[x > 29, B18:G18]
L19: CountIf[x < 11, B19:G19] + CountIf[x > 29, B19:G19]
L20: CountIf[x < 11, B20:G20] + CountIf[x > 29, B20:G20]
L21: CountIf[x < 11, B21:G21] + CountIf[x > 29, B21:G21]
L22: CountIf[x < 11, B22:G22] + CountIf[x > 29, B22:G22]
L23: CountIf[x < 11, B23:G23] + CountIf[x > 29, B23:G23]
L24: CountIf[x < 11, B24:G24] + CountIf[x > 29, B24:G24]
L25: CountIf[x < 11, B25:G25] + CountIf[x > 29, B25:G25]
L26: CountIf[x < 11, B26:G26] + CountIf[x > 29, B26:G26]
L27: CountIf[x < 11, B27:G27] + CountIf[x > 29, B27:G27]
L28: CountIf[x < 11, B28:G28] + CountIf[x > 29, B28:G28]
H29: (B29 - 20)^(2) / 20 + (C29 - 20)^(2) / 20 + (D29 - 20)^(2) / 20 + (E29 - 20)^(2) / 20 + (F29 - 20)^(2) / 20 + (G29 - 20)^(2) / 20
J29: Max[B29:G29] - Min[B29:G29]
I29 = Sum(abs(B29:G29 - 20))
L29: CountIf[x < 11, B29:G29] + CountIf[x > 29, B29:G29]
K29 = Max(abs(B29:G29 - 20))
C5 = CountIf(x ≟ 2, A5)
H5: (B5 - 20)^(2) / 20 + (C5 - 20)^(2) / 20 + (D5 - 20)^(2) / 20 + (E5 - 20)^(2) / 20 + (F5 - 20)^(2) / 20 + (G5 - 20)^(2) / 20
C6 = CountIf(x ≟ 2, A6)
H6: (B6 - 20)^(2) / 20 + (C6 - 20)^(2) / 20 + (D6 - 20)^(2) / 20 + (E6 - 20)^(2) / 20 + (F6 - 20)^(2) / 20 + (G6 - 20)^(2) / 20
C7 = CountIf(x ≟ 2, A7)
H7: (B7 - 20)^(2) / 20 + (C7 - 20)^(2) / 20 + (D7 - 20)^(2) / 20 + (E7 - 20)^(2) / 20 + (F7 - 20)^(2) / 20 + (G7 - 20)^(2) / 20
C8 = CountIf(x ≟ 2, A8)
H8: (B8 - 20)^(2) / 20 + (C8 - 20)^(2) / 20 + (D8 - 20)^(2) / 20 + (E8 - 20)^(2) / 20 + (F8 - 20)^(2) / 20 + (G8 - 20)^(2) / 20
C9 = CountIf(x ≟ 2, A9)
H9: (B9 - 20)^(2) / 20 + (C9 - 20)^(2) / 20 + (D9 - 20)^(2) / 20 + (E9 - 20)^(2) / 20 + (F9 - 20)^(2) / 20 + (G9 - 20)^(2) / 20
C10 = CountIf(x ≟ 2, A10)
H10: (B10 - 20)^(2) / 20 + (C10 - 20)^(2) / 20 + (D10 - 20)^(2) / 20 + (E10 - 20)^(2) / 20 + (F10 - 20)^(2) / 20 + (G10 - 20)^(2) / 20
C11 = CountIf(x ≟ 2, A11)
H11: (B11 - 20)^(2) / 20 + (C11 - 20)^(2) / 20 + (D11 - 20)^(2) / 20 + (E11 - 20)^(2) / 20 + (F11 - 20)^(2) / 20 + (G11 - 20)^(2) / 20
C12 = CountIf(x ≟ 2, A12)
H12: (B12 - 20)^(2) / 20 + (C12 - 20)^(2) / 20 + (D12 - 20)^(2) / 20 + (E12 - 20)^(2) / 20 + (F12 - 20)^(2) / 20 + (G12 - 20)^(2) / 20
C13 = CountIf(x ≟ 2, A13)
H13: (B13 - 20)^(2) / 20 + (C13 - 20)^(2) / 20 + (D13 - 20)^(2) / 20 + (E13 - 20)^(2) / 20 + (F13 - 20)^(2) / 20 + (G13 - 20)^(2) / 20
C14 = CountIf(x ≟ 2, A14)
H14: (B14 - 20)^(2) / 20 + (C14 - 20)^(2) / 20 + (D14 - 20)^(2) / 20 + (E14 - 20)^(2) / 20 + (F14 - 20)^(2) / 20 + (G14 - 20)^(2) / 20
C15 = CountIf(x ≟ 2, A15)
H15: (B15 - 20)^(2) / 20 + (C15 - 20)^(2) / 20 + (D15 - 20)^(2) / 20 + (E15 - 20)^(2) / 20 + (F15 - 20)^(2) / 20 + (G15 - 20)^(2) / 20
C16 = CountIf(x ≟ 2, A16)
H16: (B16 - 20)^(2) / 20 + (C16 - 20)^(2) / 20 + (D16 - 20)^(2) / 20 + (E16 - 20)^(2) / 20 + (F16 - 20)^(2) / 20 + (G16 - 20)^(2) / 20
C17 = CountIf(x ≟ 2, A17)
H17: (B17 - 20)^(2) / 20 + (C17 - 20)^(2) / 20 + (D17 - 20)^(2) / 20 + (E17 - 20)^(2) / 20 + (F17 - 20)^(2) / 20 + (G17 - 20)^(2) / 20
C18 = CountIf(x ≟ 2, A18)
H18: (B18 - 20)^(2) / 20 + (C18 - 20)^(2) / 20 + (D18 - 20)^(2) / 20 + (E18 - 20)^(2) / 20 + (F18 - 20)^(2) / 20 + (G18 - 20)^(2) / 20
C19 = CountIf(x ≟ 2, A19)
H19: (B19 - 20)^(2) / 20 + (C19 - 20)^(2) / 20 + (D19 - 20)^(2) / 20 + (E19 - 20)^(2) / 20 + (F19 - 20)^(2) / 20 + (G19 - 20)^(2) / 20
C22 = CountIf(x ≟ 2, A22)
H22: (B22 - 20)^(2) / 20 + (C22 - 20)^(2) / 20 + (D22 - 20)^(2) / 20 + (E22 - 20)^(2) / 20 + (F22 - 20)^(2) / 20 + (G22 - 20)^(2) / 20
C23 = CountIf(x ≟ 2, A23)
H23: (B23 - 20)^(2) / 20 + (C23 - 20)^(2) / 20 + (D23 - 20)^(2) / 20 + (E23 - 20)^(2) / 20 + (F23 - 20)^(2) / 20 + (G23 - 20)^(2) / 20
C24 = CountIf(x ≟ 2, A24)
H24: (B24 - 20)^(2) / 20 + (C24 - 20)^(2) / 20 + (D24 - 20)^(2) / 20 + (E24 - 20)^(2) / 20 + (F24 - 20)^(2) / 20 + (G24 - 20)^(2) / 20
C25 = CountIf(x ≟ 2, A25)
H25: (B25 - 20)^(2) / 20 + (C25 - 20)^(2) / 20 + (D25 - 20)^(2) / 20 + (E25 - 20)^(2) / 20 + (F25 - 20)^(2) / 20 + (G25 - 20)^(2) / 20
C26 = CountIf(x ≟ 2, A26)
H26: (B26 - 20)^(2) / 20 + (C26 - 20)^(2) / 20 + (D26 - 20)^(2) / 20 + (E26 - 20)^(2) / 20 + (F26 - 20)^(2) / 20 + (G26 - 20)^(2) / 20
C27 = CountIf(x ≟ 2, A27)
H27: (B27 - 20)^(2) / 20 + (C27 - 20)^(2) / 20 + (D27 - 20)^(2) / 20 + (E27 - 20)^(2) / 20 + (F27 - 20)^(2) / 20 + (G27 - 20)^(2) / 20
D4 = CountIf(x ≟ 3, A4)
E4 = CountIf(x ≟ 4, A4)
F4 = CountIf(x ≟ 5, A4)
G4 = CountIf(x ≟ 6, A4)
C4 = CountIf(x ≟ 2, A4)
H4: (B4 - 20)^(2) / 20 + (C4 - 20)^(2) / 20 + (D4 - 20)^(2) / 20 + (E4 - 20)^(2) / 20 + (F4 - 20)^(2) / 20 + (G4 - 20)^(2) / 20
B28 = CountIf(x ≟ 1, A28)
C28 = CountIf(x ≟ 2, A28)
D28 = CountIf(x ≟ 3, A28)
E28 = CountIf(x ≟ 4, A28)
F28 = CountIf(x ≟ 5, A28)
G28 = CountIf(x ≟ 6, A28)
H28: (B28 - 20)^(2) / 20 + (C28 - 20)^(2) / 20 + (D28 - 20)^(2) / 20 + (E28 - 20)^(2) / 20 + (F28 - 20)^(2) / 20 + (G28 - 20)^(2) / 20
A30 = Sequence(Random[1, 6], k, 1, 120)
C30 = CountIf(x ≟ 2, A30)
D30 = CountIf(x ≟ 3, A30)
E30 = CountIf(x ≟ 4, A30)
F30 = CountIf(x ≟ 5, A30)
G30 = CountIf(x ≟ 6, A30)
B30 = CountIf(x ≟ 1, A30)
I30 = Sum(abs(B30:G30 - 20))
K30 = Max(abs(B30:G30 - 20))
A31 = Sequence(Random[1, 6], k, 1, 120)
C31 = CountIf(x ≟ 2, A31)
D31 = CountIf(x ≟ 3, A31)
E31 = CountIf(x ≟ 4, A31)
F31 = CountIf(x ≟ 5, A31)
G31 = CountIf(x ≟ 6, A31)
B31 = CountIf(x ≟ 1, A31)
I31 = Sum(abs(B31:G31 - 20))
K31 = Max(abs(B31:G31 - 20))
A32 = Sequence(Random[1, 6], k, 1, 120)
C32 = CountIf(x ≟ 2, A32)
D32 = CountIf(x ≟ 3, A32)
E32 = CountIf(x ≟ 4, A32)
F32 = CountIf(x ≟ 5, A32)
G32 = CountIf(x ≟ 6, A32)
B32 = CountIf(x ≟ 1, A32)
I32 = Sum(abs(B32:G32 - 20))
K32 = Max(abs(B32:G32 - 20))
A33 = Sequence(Random[1, 6], k, 1, 120)
C33 = CountIf(x ≟ 2, A33)
D33 = CountIf(x ≟ 3, A33)
E33 = CountIf(x ≟ 4, A33)
F33 = CountIf(x ≟ 5, A33)
G33 = CountIf(x ≟ 6, A33)
B33 = CountIf(x ≟ 1, A33)
I33 = Sum(abs(B33:G33 - 20))
K33 = Max(abs(B33:G33 - 20))
A34 = Sequence(Random[1, 6], k, 1, 120)
C34 = CountIf(x ≟ 2, A34)
D34 = CountIf(x ≟ 3, A34)
E34 = CountIf(x ≟ 4, A34)
F34 = CountIf(x ≟ 5, A34)
G34 = CountIf(x ≟ 6, A34)
B34 = CountIf(x ≟ 1, A34)
I34 = Sum(abs(B34:G34 - 20))
K34 = Max(abs(B34:G34 - 20))
A35 = Sequence(Random[1, 6], k, 1, 120)
C35 = CountIf(x ≟ 2, A35)
D35 = CountIf(x ≟ 3, A35)
E35 = CountIf(x ≟ 4, A35)
F35 = CountIf(x ≟ 5, A35)
G35 = CountIf(x ≟ 6, A35)
B35 = CountIf(x ≟ 1, A35)
I35 = Sum(abs(B35:G35 - 20))
K35 = Max(abs(B35:G35 - 20))
A36 = Sequence(Random[1, 6], k, 1, 120)
C36 = CountIf(x ≟ 2, A36)
D36 = CountIf(x ≟ 3, A36)
E36 = CountIf(x ≟ 4, A36)
F36 = CountIf(x ≟ 5, A36)
G36 = CountIf(x ≟ 6, A36)
B36 = CountIf(x ≟ 1, A36)
I36 = Sum(abs(B36:G36 - 20))
K36 = Max(abs(B36:G36 - 20))
A37 = Sequence(Random[1, 6], k, 1, 120)
C37 = CountIf(x ≟ 2, A37)
D37 = CountIf(x ≟ 3, A37)
E37 = CountIf(x ≟ 4, A37)
F37 = CountIf(x ≟ 5, A37)
G37 = CountIf(x ≟ 6, A37)
B37 = CountIf(x ≟ 1, A37)
I37 = Sum(abs(B37:G37 - 20))
K37 = Max(abs(B37:G37 - 20))
A38 = Sequence(Random[1, 6], k, 1, 120)
C38 = CountIf(x ≟ 2, A38)
D38 = CountIf(x ≟ 3, A38)
E38 = CountIf(x ≟ 4, A38)
F38 = CountIf(x ≟ 5, A38)
G38 = CountIf(x ≟ 6, A38)
B38 = CountIf(x ≟ 1, A38)
I38 = Sum(abs(B38:G38 - 20))
K38 = Max(abs(B38:G38 - 20))
A39 = Sequence(Random[1, 6], k, 1, 120)
C39 = CountIf(x ≟ 2, A39)
D39 = CountIf(x ≟ 3, A39)
E39 = CountIf(x ≟ 4, A39)
F39 = CountIf(x ≟ 5, A39)
G39 = CountIf(x ≟ 6, A39)
B39 = CountIf(x ≟ 1, A39)
I39 = Sum(abs(B39:G39 - 20))
K39 = Max(abs(B39:G39 - 20))
A40 = Sequence(Random[1, 6], k, 1, 120)
C40 = CountIf(x ≟ 2, A40)
D40 = CountIf(x ≟ 3, A40)
E40 = CountIf(x ≟ 4, A40)
F40 = CountIf(x ≟ 5, A40)
G40 = CountIf(x ≟ 6, A40)
B40 = CountIf(x ≟ 1, A40)
I40 = Sum(abs(B40:G40 - 20))
K40 = Max(abs(B40:G40 - 20))
A41 = Sequence(Random[1, 6], k, 1, 120)
C41 = CountIf(x ≟ 2, A41)
D41 = CountIf(x ≟ 3, A41)
E41 = CountIf(x ≟ 4, A41)
F41 = CountIf(x ≟ 5, A41)
G41 = CountIf(x ≟ 6, A41)
B41 = CountIf(x ≟ 1, A41)
I41 = Sum(abs(B41:G41 - 20))
K41 = Max(abs(B41:G41 - 20))
A42 = Sequence(Random[1, 6], k, 1, 120)
C42 = CountIf(x ≟ 2, A42)
D42 = CountIf(x ≟ 3, A42)
E42 = CountIf(x ≟ 4, A42)
F42 = CountIf(x ≟ 5, A42)
G42 = CountIf(x ≟ 6, A42)
B42 = CountIf(x ≟ 1, A42)
I42 = Sum(abs(B42:G42 - 20))
K42 = Max(abs(B42:G42 - 20))
A43 = Sequence(Random[1, 6], k, 1, 120)
C43 = CountIf(x ≟ 2, A43)
D43 = CountIf(x ≟ 3, A43)
E43 = CountIf(x ≟ 4, A43)
F43 = CountIf(x ≟ 5, A43)
G43 = CountIf(x ≟ 6, A43)
B43 = CountIf(x ≟ 1, A43)
I43 = Sum(abs(B43:G43 - 20))
K43 = Max(abs(B43:G43 - 20))
A44 = Sequence(Random[1, 6], k, 1, 120)
C44 = CountIf(x ≟ 2, A44)
D44 = CountIf(x ≟ 3, A44)
E44 = CountIf(x ≟ 4, A44)
F44 = CountIf(x ≟ 5, A44)
G44 = CountIf(x ≟ 6, A44)
B44 = CountIf(x ≟ 1, A44)
I44 = Sum(abs(B44:G44 - 20))
K44 = Max(abs(B44:G44 - 20))
A45 = Sequence(Random[1, 6], k, 1, 120)
C45 = CountIf(x ≟ 2, A45)
D45 = CountIf(x ≟ 3, A45)
E45 = CountIf(x ≟ 4, A45)
F45 = CountIf(x ≟ 5, A45)
G45 = CountIf(x ≟ 6, A45)
B45 = CountIf(x ≟ 1, A45)
I45 = Sum(abs(B45:G45 - 20))
K45 = Max(abs(B45:G45 - 20))
A46 = Sequence(Random[1, 6], k, 1, 120)
C46 = CountIf(x ≟ 2, A46)
D46 = CountIf(x ≟ 3, A46)
E46 = CountIf(x ≟ 4, A46)
F46 = CountIf(x ≟ 5, A46)
G46 = CountIf(x ≟ 6, A46)
B46 = CountIf(x ≟ 1, A46)
I46 = Sum(abs(B46:G46 - 20))
K46 = Max(abs(B46:G46 - 20))
A47 = Sequence(Random[1, 6], k, 1, 120)
C47 = CountIf(x ≟ 2, A47)
D47 = CountIf(x ≟ 3, A47)
E47 = CountIf(x ≟ 4, A47)
F47 = CountIf(x ≟ 5, A47)
G47 = CountIf(x ≟ 6, A47)
B47 = CountIf(x ≟ 1, A47)
I47 = Sum(abs(B47:G47 - 20))
K47 = Max(abs(B47:G47 - 20))
A48 = Sequence(Random[1, 6], k, 1, 120)
C48 = CountIf(x ≟ 2, A48)
D48 = CountIf(x ≟ 3, A48)
E48 = CountIf(x ≟ 4, A48)
F48 = CountIf(x ≟ 5, A48)
G48 = CountIf(x ≟ 6, A48)
B48 = CountIf(x ≟ 1, A48)
I48 = Sum(abs(B48:G48 - 20))
K48 = Max(abs(B48:G48 - 20))
A49 = Sequence(Random[1, 6], k, 1, 120)
C49 = CountIf(x ≟ 2, A49)
D49 = CountIf(x ≟ 3, A49)
E49 = CountIf(x ≟ 4, A49)
F49 = CountIf(x ≟ 5, A49)
G49 = CountIf(x ≟ 6, A49)
B49 = CountIf(x ≟ 1, A49)
I49 = Sum(abs(B49:G49 - 20))
K49 = Max(abs(B49:G49 - 20))
A50 = Sequence(Random[1, 6], k, 1, 120)
C50 = CountIf(x ≟ 2, A50)
D50 = CountIf(x ≟ 3, A50)
E50 = CountIf(x ≟ 4, A50)
F50 = CountIf(x ≟ 5, A50)
G50 = CountIf(x ≟ 6, A50)
B50 = CountIf(x ≟ 1, A50)
I50 = Sum(abs(B50:G50 - 20))
K50 = Max(abs(B50:G50 - 20))
A51 = Sequence(Random[1, 6], k, 1, 120)
C51 = CountIf(x ≟ 2, A51)
D51 = CountIf(x ≟ 3, A51)
E51 = CountIf(x ≟ 4, A51)
F51 = CountIf(x ≟ 5, A51)
G51 = CountIf(x ≟ 6, A51)
B51 = CountIf(x ≟ 1, A51)
I51 = Sum(abs(B51:G51 - 20))
K51 = Max(abs(B51:G51 - 20))
A52 = Sequence(Random[1, 6], k, 1, 120)
C52 = CountIf(x ≟ 2, A52)
D52 = CountIf(x ≟ 3, A52)
E52 = CountIf(x ≟ 4, A52)
F52 = CountIf(x ≟ 5, A52)
G52 = CountIf(x ≟ 6, A52)
B52 = CountIf(x ≟ 1, A52)
I52 = Sum(abs(B52:G52 - 20))
K52 = Max(abs(B52:G52 - 20))
A53 = Sequence(Random[1, 6], k, 1, 120)
C53 = CountIf(x ≟ 2, A53)
D53 = CountIf(x ≟ 3, A53)
E53 = CountIf(x ≟ 4, A53)
F53 = CountIf(x ≟ 5, A53)
G53 = CountIf(x ≟ 6, A53)
B53 = CountIf(x ≟ 1, A53)
I53 = Sum(abs(B53:G53 - 20))
K53 = Max(abs(B53:G53 - 20))
A54 = Sequence(Random[1, 6], k, 1, 120)
C54 = CountIf(x ≟ 2, A54)
D54 = CountIf(x ≟ 3, A54)
E54 = CountIf(x ≟ 4, A54)
F54 = CountIf(x ≟ 5, A54)
G54 = CountIf(x ≟ 6, A54)
B54 = CountIf(x ≟ 1, A54)
I54 = Sum(abs(B54:G54 - 20))
K54 = Max(abs(B54:G54 - 20))
A55 = Sequence(Random[1, 6], k, 1, 120)
C55 = CountIf(x ≟ 2, A55)
D55 = CountIf(x ≟ 3, A55)
E55 = CountIf(x ≟ 4, A55)
F55 = CountIf(x ≟ 5, A55)
G55 = CountIf(x ≟ 6, A55)
B55 = CountIf(x ≟ 1, A55)
I55 = Sum(abs(B55:G55 - 20))
K55 = Max(abs(B55:G55 - 20))
A56 = Sequence(Random[1, 6], k, 1, 120)
C56 = CountIf(x ≟ 2, A56)
D56 = CountIf(x ≟ 3, A56)
E56 = CountIf(x ≟ 4, A56)
F56 = CountIf(x ≟ 5, A56)
G56 = CountIf(x ≟ 6, A56)
B56 = CountIf(x ≟ 1, A56)
I56 = Sum(abs(B56:G56 - 20))
K56 = Max(abs(B56:G56 - 20))
A57 = Sequence(Random[1, 6], k, 1, 120)
C57 = CountIf(x ≟ 2, A57)
D57 = CountIf(x ≟ 3, A57)
E57 = CountIf(x ≟ 4, A57)
F57 = CountIf(x ≟ 5, A57)
G57 = CountIf(x ≟ 6, A57)
B57 = CountIf(x ≟ 1, A57)
I57 = Sum(abs(B57:G57 - 20))
K57 = Max(abs(B57:G57 - 20))
A58 = Sequence(Random[1, 6], k, 1, 120)
C58 = CountIf(x ≟ 2, A58)
D58 = CountIf(x ≟ 3, A58)
E58 = CountIf(x ≟ 4, A58)
F58 = CountIf(x ≟ 5, A58)
G58 = CountIf(x ≟ 6, A58)
B58 = CountIf(x ≟ 1, A58)
H58: (B58 - 20)^(2) / 20 + (C58 - 20)^(2) / 20 + (D58 - 20)^(2) / 20 + (E58 - 20)^(2) / 20 + (F58 - 20)^(2) / 20 + (G58 - 20)^(2) / 20
I58 = Sum(abs(B58:G58 - 20))
J58: Max[B58:G58] - Min[B58:G58]
K58 = Max(abs(B58:G58 - 20))
L58: CountIf[x < 11, B58:G58] + CountIf[x > 29, B58:G58]
A59 = Sequence(Random[1, 6], k, 1, 120)
C59 = CountIf(x ≟ 2, A59)
D59 = CountIf(x ≟ 3, A59)
E59 = CountIf(x ≟ 4, A59)
F59 = CountIf(x ≟ 5, A59)
G59 = CountIf(x ≟ 6, A59)
B59 = CountIf(x ≟ 1, A59)
H59: (B59 - 20)^(2) / 20 + (C59 - 20)^(2) / 20 + (D59 - 20)^(2) / 20 + (E59 - 20)^(2) / 20 + (F59 - 20)^(2) / 20 + (G59 - 20)^(2) / 20
I59 = Sum(abs(B59:G59 - 20))
J59: Max[B59:G59] - Min[B59:G59]
K59 = Max(abs(B59:G59 - 20))
L59: CountIf[x < 11, B59:G59] + CountIf[x > 29, B59:G59]
A60 = Sequence(Random[1, 6], k, 1, 120)
C60 = CountIf(x ≟ 2, A60)
D60 = CountIf(x ≟ 3, A60)
E60 = CountIf(x ≟ 4, A60)
F60 = CountIf(x ≟ 5, A60)
G60 = CountIf(x ≟ 6, A60)
B60 = CountIf(x ≟ 1, A60)
H60: (B60 - 20)^(2) / 20 + (C60 - 20)^(2) / 20 + (D60 - 20)^(2) / 20 + (E60 - 20)^(2) / 20 + (F60 - 20)^(2) / 20 + (G60 - 20)^(2) / 20
I60 = Sum(abs(B60:G60 - 20))
J60: Max[B60:G60] - Min[B60:G60]
K60 = Max(abs(B60:G60 - 20))
L60: CountIf[x < 11, B60:G60] + CountIf[x > 29, B60:G60]
A61 = Sequence(Random[1, 6], k, 1, 120)
C61 = CountIf(x ≟ 2, A61)
D61 = CountIf(x ≟ 3, A61)
E61 = CountIf(x ≟ 4, A61)
F61 = CountIf(x ≟ 5, A61)
G61 = CountIf(x ≟ 6, A61)
B61 = CountIf(x ≟ 1, A61)
H61: (B61 - 20)^(2) / 20 + (C61 - 20)^(2) / 20 + (D61 - 20)^(2) / 20 + (E61 - 20)^(2) / 20 + (F61 - 20)^(2) / 20 + (G61 - 20)^(2) / 20
I61 = Sum(abs(B61:G61 - 20))
J61: Max[B61:G61] - Min[B61:G61]
K61 = Max(abs(B61:G61 - 20))
L61: CountIf[x < 11, B61:G61] + CountIf[x > 29, B61:G61]
A62 = Sequence(Random[1, 6], k, 1, 120)
C62 = CountIf(x ≟ 2, A62)
D62 = CountIf(x ≟ 3, A62)
E62 = CountIf(x ≟ 4, A62)
F62 = CountIf(x ≟ 5, A62)
G62 = CountIf(x ≟ 6, A62)
B62 = CountIf(x ≟ 1, A62)
H62: (B62 - 20)^(2) / 20 + (C62 - 20)^(2) / 20 + (D62 - 20)^(2) / 20 + (E62 - 20)^(2) / 20 + (F62 - 20)^(2) / 20 + (G62 - 20)^(2) / 20
I62 = Sum(abs(B62:G62 - 20))
J62: Max[B62:G62] - Min[B62:G62]
K62 = Max(abs(B62:G62 - 20))
L62: CountIf[x < 11, B62:G62] + CountIf[x > 29, B62:G62]
A63 = Sequence(Random[1, 6], k, 1, 120)
C63 = CountIf(x ≟ 2, A63)
D63 = CountIf(x ≟ 3, A63)
E63 = CountIf(x ≟ 4, A63)
F63 = CountIf(x ≟ 5, A63)
G63 = CountIf(x ≟ 6, A63)
B63 = CountIf(x ≟ 1, A63)
H63: (B63 - 20)^(2) / 20 + (C63 - 20)^(2) / 20 + (D63 - 20)^(2) / 20 + (E63 - 20)^(2) / 20 + (F63 - 20)^(2) / 20 + (G63 - 20)^(2) / 20
I63 = Sum(abs(B63:G63 - 20))
J63: Max[B63:G63] - Min[B63:G63]
K63 = Max(abs(B63:G63 - 20))
L63: CountIf[x < 11, B63:G63] + CountIf[x > 29, B63:G63]
A64 = Sequence(Random[1, 6], k, 1, 120)
C64 = CountIf(x ≟ 2, A64)
D64 = CountIf(x ≟ 3, A64)
E64 = CountIf(x ≟ 4, A64)
F64 = CountIf(x ≟ 5, A64)
G64 = CountIf(x ≟ 6, A64)
B64 = CountIf(x ≟ 1, A64)
H64: (B64 - 20)^(2) / 20 + (C64 - 20)^(2) / 20 + (D64 - 20)^(2) / 20 + (E64 - 20)^(2) / 20 + (F64 - 20)^(2) / 20 + (G64 - 20)^(2) / 20
I64 = Sum(abs(B64:G64 - 20))
J64: Max[B64:G64] - Min[B64:G64]
K64 = Max(abs(B64:G64 - 20))
L64: CountIf[x < 11, B64:G64] + CountIf[x > 29, B64:G64]
A65 = Sequence(Random[1, 6], k, 1, 120)
C65 = CountIf(x ≟ 2, A65)
D65 = CountIf(x ≟ 3, A65)
E65 = CountIf(x ≟ 4, A65)
F65 = CountIf(x ≟ 5, A65)
G65 = CountIf(x ≟ 6, A65)
B65 = CountIf(x ≟ 1, A65)
H65: (B65 - 20)^(2) / 20 + (C65 - 20)^(2) / 20 + (D65 - 20)^(2) / 20 + (E65 - 20)^(2) / 20 + (F65 - 20)^(2) / 20 + (G65 - 20)^(2) / 20
I65 = Sum(abs(B65:G65 - 20))
J65: Max[B65:G65] - Min[B65:G65]
K65 = Max(abs(B65:G65 - 20))
L65: CountIf[x < 11, B65:G65] + CountIf[x > 29, B65:G65]
A66 = Sequence(Random[1, 6], k, 1, 120)
C66 = CountIf(x ≟ 2, A66)
D66 = CountIf(x ≟ 3, A66)
E66 = CountIf(x ≟ 4, A66)
F66 = CountIf(x ≟ 5, A66)
G66 = CountIf(x ≟ 6, A66)
B66 = CountIf(x ≟ 1, A66)
H66: (B66 - 20)^(2) / 20 + (C66 - 20)^(2) / 20 + (D66 - 20)^(2) / 20 + (E66 - 20)^(2) / 20 + (F66 - 20)^(2) / 20 + (G66 - 20)^(2) / 20
I66 = Sum(abs(B66:G66 - 20))
J66: Max[B66:G66] - Min[B66:G66]
K66 = Max(abs(B66:G66 - 20))
L66: CountIf[x < 11, B66:G66] + CountIf[x > 29, B66:G66]
A67 = Sequence(Random[1, 6], k, 1, 120)
C67 = CountIf(x ≟ 2, A67)
D67 = CountIf(x ≟ 3, A67)
E67 = CountIf(x ≟ 4, A67)
F67 = CountIf(x ≟ 5, A67)
G67 = CountIf(x ≟ 6, A67)
B67 = CountIf(x ≟ 1, A67)
H67: (B67 - 20)^(2) / 20 + (C67 - 20)^(2) / 20 + (D67 - 20)^(2) / 20 + (E67 - 20)^(2) / 20 + (F67 - 20)^(2) / 20 + (G67 - 20)^(2) / 20
I67 = Sum(abs(B67:G67 - 20))
J67: Max[B67:G67] - Min[B67:G67]
K67 = Max(abs(B67:G67 - 20))
L67: CountIf[x < 11, B67:G67] + CountIf[x > 29, B67:G67]
A68 = Sequence(Random[1, 6], k, 1, 120)
C68 = CountIf(x ≟ 2, A68)
D68 = CountIf(x ≟ 3, A68)
E68 = CountIf(x ≟ 4, A68)
F68 = CountIf(x ≟ 5, A68)
G68 = CountIf(x ≟ 6, A68)
B68 = CountIf(x ≟ 1, A68)
H68: (B68 - 20)^(2) / 20 + (C68 - 20)^(2) / 20 + (D68 - 20)^(2) / 20 + (E68 - 20)^(2) / 20 + (F68 - 20)^(2) / 20 + (G68 - 20)^(2) / 20
I68 = Sum(abs(B68:G68 - 20))
J68: Max[B68:G68] - Min[B68:G68]
K68 = Max(abs(B68:G68 - 20))
L68: CountIf[x < 11, B68:G68] + CountIf[x > 29, B68:G68]
A69 = Sequence(Random[1, 6], k, 1, 120)
C69 = CountIf(x ≟ 2, A69)
D69 = CountIf(x ≟ 3, A69)
E69 = CountIf(x ≟ 4, A69)
F69 = CountIf(x ≟ 5, A69)
G69 = CountIf(x ≟ 6, A69)
B69 = CountIf(x ≟ 1, A69)
H69: (B69 - 20)^(2) / 20 + (C69 - 20)^(2) / 20 + (D69 - 20)^(2) / 20 + (E69 - 20)^(2) / 20 + (F69 - 20)^(2) / 20 + (G69 - 20)^(2) / 20
I69 = Sum(abs(B69:G69 - 20))
J69: Max[B69:G69] - Min[B69:G69]
K69 = Max(abs(B69:G69 - 20))
L69: CountIf[x < 11, B69:G69] + CountIf[x > 29, B69:G69]
A70 = Sequence(Random[1, 6], k, 1, 120)
C70 = CountIf(x ≟ 2, A70)
D70 = CountIf(x ≟ 3, A70)
E70 = CountIf(x ≟ 4, A70)
F70 = CountIf(x ≟ 5, A70)
G70 = CountIf(x ≟ 6, A70)
B70 = CountIf(x ≟ 1, A70)
H70: (B70 - 20)^(2) / 20 + (C70 - 20)^(2) / 20 + (D70 - 20)^(2) / 20 + (E70 - 20)^(2) / 20 + (F70 - 20)^(2) / 20 + (G70 - 20)^(2) / 20
I70 = Sum(abs(B70:G70 - 20))
J70: Max[B70:G70] - Min[B70:G70]
K70 = Max(abs(B70:G70 - 20))
L70: CountIf[x < 11, B70:G70] + CountIf[x > 29, B70:G70]
A71 = Sequence(Random[1, 6], k, 1, 120)
C71 = CountIf(x ≟ 2, A71)
D71 = CountIf(x ≟ 3, A71)
E71 = CountIf(x ≟ 4, A71)
F71 = CountIf(x ≟ 5, A71)
G71 = CountIf(x ≟ 6, A71)
B71 = CountIf(x ≟ 1, A71)
H71: (B71 - 20)^(2) / 20 + (C71 - 20)^(2) / 20 + (D71 - 20)^(2) / 20 + (E71 - 20)^(2) / 20 + (F71 - 20)^(2) / 20 + (G71 - 20)^(2) / 20
I71 = Sum(abs(B71:G71 - 20))
J71: Max[B71:G71] - Min[B71:G71]
K71 = Max(abs(B71:G71 - 20))
L71: CountIf[x < 11, B71:G71] + CountIf[x > 29, B71:G71]
A72 = Sequence(Random[1, 6], k, 1, 120)
C72 = CountIf(x ≟ 2, A72)
D72 = CountIf(x ≟ 3, A72)
E72 = CountIf(x ≟ 4, A72)
F72 = CountIf(x ≟ 5, A72)
G72 = CountIf(x ≟ 6, A72)
B72 = CountIf(x ≟ 1, A72)
H72: (B72 - 20)^(2) / 20 + (C72 - 20)^(2) / 20 + (D72 - 20)^(2) / 20 + (E72 - 20)^(2) / 20 + (F72 - 20)^(2) / 20 + (G72 - 20)^(2) / 20
I72 = Sum(abs(B72:G72 - 20))
J72: Max[B72:G72] - Min[B72:G72]
K72 = Max(abs(B72:G72 - 20))
L72: CountIf[x < 11, B72:G72] + CountIf[x > 29, B72:G72]
A73 = Sequence(Random[1, 6], k, 1, 120)
C73 = CountIf(x ≟ 2, A73)
D73 = CountIf(x ≟ 3, A73)
E73 = CountIf(x ≟ 4, A73)
F73 = CountIf(x ≟ 5, A73)
G73 = CountIf(x ≟ 6, A73)
B73 = CountIf(x ≟ 1, A73)
H73: (B73 - 20)^(2) / 20 + (C73 - 20)^(2) / 20 + (D73 - 20)^(2) / 20 + (E73 - 20)^(2) / 20 + (F73 - 20)^(2) / 20 + (G73 - 20)^(2) / 20
I73 = Sum(abs(B73:G73 - 20))
J73: Max[B73:G73] - Min[B73:G73]
K73 = Max(abs(B73:G73 - 20))
L73: CountIf[x < 11, B73:G73] + CountIf[x > 29, B73:G73]
A74 = Sequence(Random[1, 6], k, 1, 120)
C74 = CountIf(x ≟ 2, A74)
D74 = CountIf(x ≟ 3, A74)
E74 = CountIf(x ≟ 4, A74)
F74 = CountIf(x ≟ 5, A74)
G74 = CountIf(x ≟ 6, A74)
B74 = CountIf(x ≟ 1, A74)
H74: (B74 - 20)^(2) / 20 + (C74 - 20)^(2) / 20 + (D74 - 20)^(2) / 20 + (E74 - 20)^(2) / 20 + (F74 - 20)^(2) / 20 + (G74 - 20)^(2) / 20
I74 = Sum(abs(B74:G74 - 20))
J74: Max[B74:G74] - Min[B74:G74]
K74 = Max(abs(B74:G74 - 20))
L74: CountIf[x < 11, B74:G74] + CountIf[x > 29, B74:G74]
A75 = Sequence(Random[1, 6], k, 1, 120)
C75 = CountIf(x ≟ 2, A75)
D75 = CountIf(x ≟ 3, A75)
E75 = CountIf(x ≟ 4, A75)
F75 = CountIf(x ≟ 5, A75)
G75 = CountIf(x ≟ 6, A75)
B75 = CountIf(x ≟ 1, A75)
H75: (B75 - 20)^(2) / 20 + (C75 - 20)^(2) / 20 + (D75 - 20)^(2) / 20 + (E75 - 20)^(2) / 20 + (F75 - 20)^(2) / 20 + (G75 - 20)^(2) / 20
I75 = Sum(abs(B75:G75 - 20))
J75: Max[B75:G75] - Min[B75:G75]
K75 = Max(abs(B75:G75 - 20))
L75: CountIf[x < 11, B75:G75] + CountIf[x > 29, B75:G75]
A76 = Sequence(Random[1, 6], k, 1, 120)
C76 = CountIf(x ≟ 2, A76)
D76 = CountIf(x ≟ 3, A76)
E76 = CountIf(x ≟ 4, A76)
F76 = CountIf(x ≟ 5, A76)
G76 = CountIf(x ≟ 6, A76)
B76 = CountIf(x ≟ 1, A76)
H76: (B76 - 20)^(2) / 20 + (C76 - 20)^(2) / 20 + (D76 - 20)^(2) / 20 + (E76 - 20)^(2) / 20 + (F76 - 20)^(2) / 20 + (G76 - 20)^(2) / 20
I76 = Sum(abs(B76:G76 - 20))
J76: Max[B76:G76] - Min[B76:G76]
K76 = Max(abs(B76:G76 - 20))
L76: CountIf[x < 11, B76:G76] + CountIf[x > 29, B76:G76]
A77 = Sequence(Random[1, 6], k, 1, 120)
C77 = CountIf(x ≟ 2, A77)
D77 = CountIf(x ≟ 3, A77)
E77 = CountIf(x ≟ 4, A77)
F77 = CountIf(x ≟ 5, A77)
G77 = CountIf(x ≟ 6, A77)
B77 = CountIf(x ≟ 1, A77)
H77: (B77 - 20)^(2) / 20 + (C77 - 20)^(2) / 20 + (D77 - 20)^(2) / 20 + (E77 - 20)^(2) / 20 + (F77 - 20)^(2) / 20 + (G77 - 20)^(2) / 20
I77 = Sum(abs(B77:G77 - 20))
J77: Max[B77:G77] - Min[B77:G77]
K77 = Max(abs(B77:G77 - 20))
L77: CountIf[x < 11, B77:G77] + CountIf[x > 29, B77:G77]
A78 = Sequence(Random[1, 6], k, 1, 120)
C78 = CountIf(x ≟ 2, A78)
D78 = CountIf(x ≟ 3, A78)
E78 = CountIf(x ≟ 4, A78)
F78 = CountIf(x ≟ 5, A78)
G78 = CountIf(x ≟ 6, A78)
B78 = CountIf(x ≟ 1, A78)
H78: (B78 - 20)^(2) / 20 + (C78 - 20)^(2) / 20 + (D78 - 20)^(2) / 20 + (E78 - 20)^(2) / 20 + (F78 - 20)^(2) / 20 + (G78 - 20)^(2) / 20
I78 = Sum(abs(B78:G78 - 20))
J78: Max[B78:G78] - Min[B78:G78]
K78 = Max(abs(B78:G78 - 20))
L78: CountIf[x < 11, B78:G78] + CountIf[x > 29, B78:G78]
A79 = Sequence(Random[1, 6], k, 1, 120)
C79 = CountIf(x ≟ 2, A79)
D79 = CountIf(x ≟ 3, A79)
E79 = CountIf(x ≟ 4, A79)
F79 = CountIf(x ≟ 5, A79)
G79 = CountIf(x ≟ 6, A79)
B79 = CountIf(x ≟ 1, A79)
H79: (B79 - 20)^(2) / 20 + (C79 - 20)^(2) / 20 + (D79 - 20)^(2) / 20 + (E79 - 20)^(2) / 20 + (F79 - 20)^(2) / 20 + (G79 - 20)^(2) / 20
I79 = Sum(abs(B79:G79 - 20))
J79: Max[B79:G79] - Min[B79:G79]
K79 = Max(abs(B79:G79 - 20))
L79: CountIf[x < 11, B79:G79] + CountIf[x > 29, B79:G79]
A80 = Sequence(Random[1, 6], k, 1, 120)
C80 = CountIf(x ≟ 2, A80)
D80 = CountIf(x ≟ 3, A80)
E80 = CountIf(x ≟ 4, A80)
F80 = CountIf(x ≟ 5, A80)
G80 = CountIf(x ≟ 6, A80)
B80 = CountIf(x ≟ 1, A80)
H80: (B80 - 20)^(2) / 20 + (C80 - 20)^(2) / 20 + (D80 - 20)^(2) / 20 + (E80 - 20)^(2) / 20 + (F80 - 20)^(2) / 20 + (G80 - 20)^(2) / 20
I80 = Sum(abs(B80:G80 - 20))
J80: Max[B80:G80] - Min[B80:G80]
K80 = Max(abs(B80:G80 - 20))
L80: CountIf[x < 11, B80:G80] + CountIf[x > 29, B80:G80]
A81 = Sequence(Random[1, 6], k, 1, 120)
C81 = CountIf(x ≟ 2, A81)
D81 = CountIf(x ≟ 3, A81)
E81 = CountIf(x ≟ 4, A81)
F81 = CountIf(x ≟ 5, A81)
G81 = CountIf(x ≟ 6, A81)
B81 = CountIf(x ≟ 1, A81)
H81: (B81 - 20)^(2) / 20 + (C81 - 20)^(2) / 20 + (D81 - 20)^(2) / 20 + (E81 - 20)^(2) / 20 + (F81 - 20)^(2) / 20 + (G81 - 20)^(2) / 20
I81 = Sum(abs(B81:G81 - 20))
J81: Max[B81:G81] - Min[B81:G81]
K81 = Max(abs(B81:G81 - 20))
L81: CountIf[x < 11, B81:G81] + CountIf[x > 29, B81:G81]
A82 = Sequence(Random[1, 6], k, 1, 120)
C82 = CountIf(x ≟ 2, A82)
D82 = CountIf(x ≟ 3, A82)
E82 = CountIf(x ≟ 4, A82)
F82 = CountIf(x ≟ 5, A82)
G82 = CountIf(x ≟ 6, A82)
B82 = CountIf(x ≟ 1, A82)
H82: (B82 - 20)^(2) / 20 + (C82 - 20)^(2) / 20 + (D82 - 20)^(2) / 20 + (E82 - 20)^(2) / 20 + (F82 - 20)^(2) / 20 + (G82 - 20)^(2) / 20
I82 = Sum(abs(B82:G82 - 20))
J82: Max[B82:G82] - Min[B82:G82]
K82 = Max(abs(B82:G82 - 20))
L82: CountIf[x < 11, B82:G82] + CountIf[x > 29, B82:G82]
A83 = Sequence(Random[1, 6], k, 1, 120)
C83 = CountIf(x ≟ 2, A83)
D83 = CountIf(x ≟ 3, A83)
E83 = CountIf(x ≟ 4, A83)
F83 = CountIf(x ≟ 5, A83)
G83 = CountIf(x ≟ 6, A83)
B83 = CountIf(x ≟ 1, A83)
H83: (B83 - 20)^(2) / 20 + (C83 - 20)^(2) / 20 + (D83 - 20)^(2) / 20 + (E83 - 20)^(2) / 20 + (F83 - 20)^(2) / 20 + (G83 - 20)^(2) / 20
I83 = Sum(abs(B83:G83 - 20))
J83: Max[B83:G83] - Min[B83:G83]
K83 = Max(abs(B83:G83 - 20))
L83: CountIf[x < 11, B83:G83] + CountIf[x > 29, B83:G83]
A84 = Sequence(Random[1, 6], k, 1, 120)
C84 = CountIf(x ≟ 2, A84)
D84 = CountIf(x ≟ 3, A84)
E84 = CountIf(x ≟ 4, A84)
F84 = CountIf(x ≟ 5, A84)
G84 = CountIf(x ≟ 6, A84)
B84 = CountIf(x ≟ 1, A84)
H84: (B84 - 20)^(2) / 20 + (C84 - 20)^(2) / 20 + (D84 - 20)^(2) / 20 + (E84 - 20)^(2) / 20 + (F84 - 20)^(2) / 20 + (G84 - 20)^(2) / 20
I84 = Sum(abs(B84:G84 - 20))
J84: Max[B84:G84] - Min[B84:G84]
K84 = Max(abs(B84:G84 - 20))
L84: CountIf[x < 11, B84:G84] + CountIf[x > 29, B84:G84]
A85 = Sequence(Random[1, 6], k, 1, 120)
C85 = CountIf(x ≟ 2, A85)
D85 = CountIf(x ≟ 3, A85)
E85 = CountIf(x ≟ 4, A85)
F85 = CountIf(x ≟ 5, A85)
G85 = CountIf(x ≟ 6, A85)
B85 = CountIf(x ≟ 1, A85)
H85: (B85 - 20)^(2) / 20 + (C85 - 20)^(2) / 20 + (D85 - 20)^(2) / 20 + (E85 - 20)^(2) / 20 + (F85 - 20)^(2) / 20 + (G85 - 20)^(2) / 20
I85 = Sum(abs(B85:G85 - 20))
J85: Max[B85:G85] - Min[B85:G85]
K85 = Max(abs(B85:G85 - 20))
L85: CountIf[x < 11, B85:G85] + CountIf[x > 29, B85:G85]
A86 = Sequence(Random[1, 6], k, 1, 120)
C86 = CountIf(x ≟ 2, A86)
D86 = CountIf(x ≟ 3, A86)
E86 = CountIf(x ≟ 4, A86)
F86 = CountIf(x ≟ 5, A86)
G86 = CountIf(x ≟ 6, A86)
B86 = CountIf(x ≟ 1, A86)
H86: (B86 - 20)^(2) / 20 + (C86 - 20)^(2) / 20 + (D86 - 20)^(2) / 20 + (E86 - 20)^(2) / 20 + (F86 - 20)^(2) / 20 + (G86 - 20)^(2) / 20
I86 = Sum(abs(B86:G86 - 20))
J86: Max[B86:G86] - Min[B86:G86]
K86 = Max(abs(B86:G86 - 20))
L86: CountIf[x < 11, B86:G86] + CountIf[x > 29, B86:G86]
A87 = Sequence(Random[1, 6], k, 1, 120)
C87 = CountIf(x ≟ 2, A87)
D87 = CountIf(x ≟ 3, A87)
E87 = CountIf(x ≟ 4, A87)
F87 = CountIf(x ≟ 5, A87)
G87 = CountIf(x ≟ 6, A87)
B87 = CountIf(x ≟ 1, A87)
H87: (B87 - 20)^(2) / 20 + (C87 - 20)^(2) / 20 + (D87 - 20)^(2) / 20 + (E87 - 20)^(2) / 20 + (F87 - 20)^(2) / 20 + (G87 - 20)^(2) / 20
I87 = Sum(abs(B87:G87 - 20))
J87: Max[B87:G87] - Min[B87:G87]
K87 = Max(abs(B87:G87 - 20))
L87: CountIf[x < 11, B87:G87] + CountIf[x > 29, B87:G87]
I88 = Sum(abs(B88:G88 - 20))
J88: Max[B88:G88] - Min[B88:G88]
K88 = Max(abs(B88:G88 - 20))
L88: CountIf[x < 11, B88:G88] + CountIf[x > 29, B88:G88]
A89 = Sequence(Random[1, 6], k, 1, 120)
C89 = CountIf(x ≟ 2, A89)
D89 = CountIf(x ≟ 3, A89)
E89 = CountIf(x ≟ 4, A89)
F89 = CountIf(x ≟ 5, A89)
G89 = CountIf(x ≟ 6, A89)
B89 = CountIf(x ≟ 1, A89)
H89: (B89 - 20)^(2) / 20 + (C89 - 20)^(2) / 20 + (D89 - 20)^(2) / 20 + (E89 - 20)^(2) / 20 + (F89 - 20)^(2) / 20 + (G89 - 20)^(2) / 20
I89 = Sum(abs(B89:G89 - 20))
J89: Max[B89:G89] - Min[B89:G89]
K89 = Max(abs(B89:G89 - 20))
L89: CountIf[x < 11, B89:G89] + CountIf[x > 29, B89:G89]
A90 = Sequence(Random[1, 6], k, 1, 120)
C90 = CountIf(x ≟ 2, A90)
D90 = CountIf(x ≟ 3, A90)
E90 = CountIf(x ≟ 4, A90)
F90 = CountIf(x ≟ 5, A90)
G90 = CountIf(x ≟ 6, A90)
B90 = CountIf(x ≟ 1, A90)
H90: (B90 - 20)^(2) / 20 + (C90 - 20)^(2) / 20 + (D90 - 20)^(2) / 20 + (E90 - 20)^(2) / 20 + (F90 - 20)^(2) / 20 + (G90 - 20)^(2) / 20
I90 = Sum(abs(B90:G90 - 20))
J90: Max[B90:G90] - Min[B90:G90]
K90 = Max(abs(B90:G90 - 20))
L90: CountIf[x < 11, B90:G90] + CountIf[x > 29, B90:G90]
A91 = Sequence(Random[1, 6], k, 1, 120)
C91 = CountIf(x ≟ 2, A91)
D91 = CountIf(x ≟ 3, A91)
E91 = CountIf(x ≟ 4, A91)
F91 = CountIf(x ≟ 5, A91)
G91 = CountIf(x ≟ 6, A91)
B91 = CountIf(x ≟ 1, A91)
H91: (B91 - 20)^(2) / 20 + (C91 - 20)^(2) / 20 + (D91 - 20)^(2) / 20 + (E91 - 20)^(2) / 20 + (F91 - 20)^(2) / 20 + (G91 - 20)^(2) / 20
I91 = Sum(abs(B91:G91 - 20))
J91: Max[B91:G91] - Min[B91:G91]
K91 = Max(abs(B91:G91 - 20))
L91: CountIf[x < 11, B91:G91] + CountIf[x > 29, B91:G91]
A92 = Sequence(Random[1, 6], k, 1, 120)
C92 = CountIf(x ≟ 2, A92)
D92 = CountIf(x ≟ 3, A92)
E92 = CountIf(x ≟ 4, A92)
F92 = CountIf(x ≟ 5, A92)
G92 = CountIf(x ≟ 6, A92)
B92 = CountIf(x ≟ 1, A92)
H92: (B92 - 20)^(2) / 20 + (C92 - 20)^(2) / 20 + (D92 - 20)^(2) / 20 + (E92 - 20)^(2) / 20 + (F92 - 20)^(2) / 20 + (G92 - 20)^(2) / 20
I92 = Sum(abs(B92:G92 - 20))
J92: Max[B92:G92] - Min[B92:G92]
K92 = Max(abs(B92:G92 - 20))
L92: CountIf[x < 11, B92:G92] + CountIf[x > 29, B92:G92]
A93 = Sequence(Random[1, 6], k, 1, 120)
C93 = CountIf(x ≟ 2, A93)
D93 = CountIf(x ≟ 3, A93)
E93 = CountIf(x ≟ 4, A93)
F93 = CountIf(x ≟ 5, A93)
G93 = CountIf(x ≟ 6, A93)
B93 = CountIf(x ≟ 1, A93)
H93: (B93 - 20)^(2) / 20 + (C93 - 20)^(2) / 20 + (D93 - 20)^(2) / 20 + (E93 - 20)^(2) / 20 + (F93 - 20)^(2) / 20 + (G93 - 20)^(2) / 20
I93 = Sum(abs(B93:G93 - 20))
J93: Max[B93:G93] - Min[B93:G93]
K93 = Max(abs(B93:G93 - 20))
L93: CountIf[x < 11, B93:G93] + CountIf[x > 29, B93:G93]
A94 = Sequence(Random[1, 6], k, 1, 120)
C94 = CountIf(x ≟ 2, A94)
D94 = CountIf(x ≟ 3, A94)
E94 = CountIf(x ≟ 4, A94)
F94 = CountIf(x ≟ 5, A94)
G94 = CountIf(x ≟ 6, A94)
B94 = CountIf(x ≟ 1, A94)
H94: (B94 - 20)^(2) / 20 + (C94 - 20)^(2) / 20 + (D94 - 20)^(2) / 20 + (E94 - 20)^(2) / 20 + (F94 - 20)^(2) / 20 + (G94 - 20)^(2) / 20
I94 = Sum(abs(B94:G94 - 20))
J94: Max[B94:G94] - Min[B94:G94]
K94 = Max(abs(B94:G94 - 20))
L94: CountIf[x < 11, B94:G94] + CountIf[x > 29, B94:G94]
A95 = Sequence(Random[1, 6], k, 1, 120)
C95 = CountIf(x ≟ 2, A95)
D95 = CountIf(x ≟ 3, A95)
E95 = CountIf(x ≟ 4, A95)
F95 = CountIf(x ≟ 5, A95)
G95 = CountIf(x ≟ 6, A95)
B95 = CountIf(x ≟ 1, A95)
H95: (B95 - 20)^(2) / 20 + (C95 - 20)^(2) / 20 + (D95 - 20)^(2) / 20 + (E95 - 20)^(2) / 20 + (F95 - 20)^(2) / 20 + (G95 - 20)^(2) / 20
I95 = Sum(abs(B95:G95 - 20))
J95: Max[B95:G95] - Min[B95:G95]
K95 = Max(abs(B95:G95 - 20))
L95: CountIf[x < 11, B95:G95] + CountIf[x > 29, B95:G95]
A96 = Sequence(Random[1, 6], k, 1, 120)
C96 = CountIf(x ≟ 2, A96)
D96 = CountIf(x ≟ 3, A96)
E96 = CountIf(x ≟ 4, A96)
F96 = CountIf(x ≟ 5, A96)
G96 = CountIf(x ≟ 6, A96)
B96 = CountIf(x ≟ 1, A96)
H96: (B96 - 20)^(2) / 20 + (C96 - 20)^(2) / 20 + (D96 - 20)^(2) / 20 + (E96 - 20)^(2) / 20 + (F96 - 20)^(2) / 20 + (G96 - 20)^(2) / 20
I96 = Sum(abs(B96:G96 - 20))
J96: Max[B96:G96] - Min[B96:G96]
K96 = Max(abs(B96:G96 - 20))
L96: CountIf[x < 11, B96:G96] + CountIf[x > 29, B96:G96]
A97 = Sequence(Random[1, 6], k, 1, 120)
C97 = CountIf(x ≟ 2, A97)
D97 = CountIf(x ≟ 3, A97)
E97 = CountIf(x ≟ 4, A97)
F97 = CountIf(x ≟ 5, A97)
G97 = CountIf(x ≟ 6, A97)
B97 = CountIf(x ≟ 1, A97)
H97: (B97 - 20)^(2) / 20 + (C97 - 20)^(2) / 20 + (D97 - 20)^(2) / 20 + (E97 - 20)^(2) / 20 + (F97 - 20)^(2) / 20 + (G97 - 20)^(2) / 20
I97 = Sum(abs(B97:G97 - 20))
J97: Max[B97:G97] - Min[B97:G97]
K97 = Max(abs(B97:G97 - 20))
L97: CountIf[x < 11, B97:G97] + CountIf[x > 29, B97:G97]
A98 = Sequence(Random[1, 6], k, 1, 120)
C98 = CountIf(x ≟ 2, A98)
D98 = CountIf(x ≟ 3, A98)
E98 = CountIf(x ≟ 4, A98)
F98 = CountIf(x ≟ 5, A98)
G98 = CountIf(x ≟ 6, A98)
B98 = CountIf(x ≟ 1, A98)
H98: (B98 - 20)^(2) / 20 + (C98 - 20)^(2) / 20 + (D98 - 20)^(2) / 20 + (E98 - 20)^(2) / 20 + (F98 - 20)^(2) / 20 + (G98 - 20)^(2) / 20
I98 = Sum(abs(B98:G98 - 20))
J98: Max[B98:G98] - Min[B98:G98]
K98 = Max(abs(B98:G98 - 20))
L98: CountIf[x < 11, B98:G98] + CountIf[x > 29, B98:G98]
A99 = Sequence(Random[1, 6], k, 1, 120)
C99 = CountIf(x ≟ 2, A99)
D99 = CountIf(x ≟ 3, A99)
E99 = CountIf(x ≟ 4, A99)
F99 = CountIf(x ≟ 5, A99)
G99 = CountIf(x ≟ 6, A99)
B99 = CountIf(x ≟ 1, A99)
H99: (B99 - 20)^(2) / 20 + (C99 - 20)^(2) / 20 + (D99 - 20)^(2) / 20 + (E99 - 20)^(2) / 20 + (F99 - 20)^(2) / 20 + (G99 - 20)^(2) / 20
I99 = Sum(abs(B99:G99 - 20))
J99: Max[B99:G99] - Min[B99:G99]
K99 = Max(abs(B99:G99 - 20))
L99: CountIf[x < 11, B99:G99] + CountIf[x > 29, B99:G99]
A100 = Sequence(Random[1, 6], k, 1, 120)
C100 = CountIf(x ≟ 2, A100)
D100 = CountIf(x ≟ 3, A100)
E100 = CountIf(x ≟ 4, A100)
F100 = CountIf(x ≟ 5, A100)
G100 = CountIf(x ≟ 6, A100)
B100 = CountIf(x ≟ 1, A100)
H100: (B100 - 20)^(2) / 20 + (C100 - 20)^(2) / 20 + (D100 - 20)^(2) / 20 + (E100 - 20)^(2) / 20 + (F100 - 20)^(2) / 20 + (G100 - 20)^(2) / 20
I100 = Sum(abs(B100:G100 - 20))
J100: Max[B100:G100] - Min[B100:G100]
K100 = Max(abs(B100:G100 - 20))
L100: CountIf[x < 11, B100:G100] + CountIf[x > 29, B100:G100]
A101_{1}: {}
D101 = CountIf(x ≟ 3, A101)
E101 = CountIf(x ≟ 4, A101)
F101 = CountIf(x ≟ 5, A101)
G101 = CountIf(x ≟ 6, A101)
B101 = CountIf(x ≟ 1, A101)
C101 = CountIf(x ≟ 2, A101)
H101: (B101 - 20)^(2) / 20 + (C101 - 20)^(2) / 20 + (D101 - 20)^(2) / 20 + (E101 - 20)^(2) / 20 + (F101 - 20)^(2) / 20 + (G101 - 20)^(2) / 20
I101 = Sum(abs(B101:G101 - 20))
J101: Max[B101:G101] - Min[B101:G101]
K101 = Max(abs(B101:G101 - 20))
L101: CountIf[x < 11, B101:G101] + CountIf[x > 29, B101:G101]
A102 = Sequence(Random[1, 6], k, 1, 120)
C102 = CountIf(x ≟ 2, A102)
D102 = CountIf(x ≟ 3, A102)
E102 = CountIf(x ≟ 4, A102)
F102 = CountIf(x ≟ 5, A102)
G102 = CountIf(x ≟ 6, A102)
B102 = CountIf(x ≟ 1, A102)
H102: (B102 - 20)^(2) / 20 + (C102 - 20)^(2) / 20 + (D102 - 20)^(2) / 20 + (E102 - 20)^(2) / 20 + (F102 - 20)^(2) / 20 + (G102 - 20)^(2) / 20
I102 = Sum(abs(B102:G102 - 20))
J102: Max[B102:G102] - Min[B102:G102]
K102 = Max(abs(B102:G102 - 20))
L102: CountIf[x < 11, B102:G102] + CountIf[x > 29, B102:G102]
A103 = Sequence(Random[1, 6], k, 1, 120)
C103 = CountIf(x ≟ 2, A103)
D103 = CountIf(x ≟ 3, A103)
E103 = CountIf(x ≟ 4, A103)
F103 = CountIf(x ≟ 5, A103)
G103 = CountIf(x ≟ 6, A103)
B103 = CountIf(x ≟ 1, A103)
H103: (B103 - 20)^(2) / 20 + (C103 - 20)^(2) / 20 + (D103 - 20)^(2) / 20 + (E103 - 20)^(2) / 20 + (F103 - 20)^(2) / 20 + (G103 - 20)^(2) / 20
I103 = Sum(abs(B103:G103 - 20))
J103: Max[B103:G103] - Min[B103:G103]
K103 = Max(abs(B103:G103 - 20))
L103: CountIf[x < 11, B103:G103] + CountIf[x > 29, B103:G103]
A104 = Sequence(Random[1, 6], k, 1, 120)
C104 = CountIf(x ≟ 2, A104)
D104 = CountIf(x ≟ 3, A104)
E104 = CountIf(x ≟ 4, A104)
F104 = CountIf(x ≟ 5, A104)
G104 = CountIf(x ≟ 6, A104)
B104 = CountIf(x ≟ 1, A104)
H104: (B104 - 20)^(2) / 20 + (C104 - 20)^(2) / 20 + (D104 - 20)^(2) / 20 + (E104 - 20)^(2) / 20 + (F104 - 20)^(2) / 20 + (G104 - 20)^(2) / 20
I104 = Sum(abs(B104:G104 - 20))
J104: Max[B104:G104] - Min[B104:G104]
K104 = Max(abs(B104:G104 - 20))
L104: CountIf[x < 11, B104:G104] + CountIf[x > 29, B104:G104]
A105 = Sequence(Random[1, 6], k, 1, 120)
C105 = CountIf(x ≟ 2, A105)
D105 = CountIf(x ≟ 3, A105)
E105 = CountIf(x ≟ 4, A105)
F105 = CountIf(x ≟ 5, A105)
G105 = CountIf(x ≟ 6, A105)
B105 = CountIf(x ≟ 1, A105)
H105: (B105 - 20)^(2) / 20 + (C105 - 20)^(2) / 20 + (D105 - 20)^(2) / 20 + (E105 - 20)^(2) / 20 + (F105 - 20)^(2) / 20 + (G105 - 20)^(2) / 20
I105 = Sum(abs(B105:G105 - 20))
J105: Max[B105:G105] - Min[B105:G105]
K105 = Max(abs(B105:G105 - 20))
L105: CountIf[x < 11, B105:G105] + CountIf[x > 29, B105:G105]
A106 = Sequence(Random[1, 6], k, 1, 120)
C106 = CountIf(x ≟ 2, A106)
D106 = CountIf(x ≟ 3, A106)
E106 = CountIf(x ≟ 4, A106)
F106 = CountIf(x ≟ 5, A106)
G106 = CountIf(x ≟ 6, A106)
B106 = CountIf(x ≟ 1, A106)
H106: (B106 - 20)^(2) / 20 + (C106 - 20)^(2) / 20 + (D106 - 20)^(2) / 20 + (E106 - 20)^(2) / 20 + (F106 - 20)^(2) / 20 + (G106 - 20)^(2) / 20
I106 = Sum(abs(B106:G106 - 20))
J106: Max[B106:G106] - Min[B106:G106]
K106 = Max(abs(B106:G106 - 20))
L106: CountIf[x < 11, B106:G106] + CountIf[x > 29, B106:G106]
A107 = Sequence(Random[1, 6], k, 1, 120)
C107 = CountIf(x ≟ 2, A107)
D107 = CountIf(x ≟ 3, A107)
E107 = CountIf(x ≟ 4, A107)
F107 = CountIf(x ≟ 5, A107)
G107 = CountIf(x ≟ 6, A107)
B107 = CountIf(x ≟ 1, A107)
H107: (B107 - 20)^(2) / 20 + (C107 - 20)^(2) / 20 + (D107 - 20)^(2) / 20 + (E107 - 20)^(2) / 20 + (F107 - 20)^(2) / 20 + (G107 - 20)^(2) / 20
I107 = Sum(abs(B107:G107 - 20))
J107: Max[B107:G107] - Min[B107:G107]
K107 = Max(abs(B107:G107 - 20))
L107: CountIf[x < 11, B107:G107] + CountIf[x > 29, B107:G107]
A108 = Sequence(Random[1, 6], k, 1, 120)
C108 = CountIf(x ≟ 2, A108)
D108 = CountIf(x ≟ 3, A108)
E108 = CountIf(x ≟ 4, A108)
F108 = CountIf(x ≟ 5, A108)
G108 = CountIf(x ≟ 6, A108)
B108 = CountIf(x ≟ 1, A108)
H108: (B108 - 20)^(2) / 20 + (C108 - 20)^(2) / 20 + (D108 - 20)^(2) / 20 + (E108 - 20)^(2) / 20 + (F108 - 20)^(2) / 20 + (G108 - 20)^(2) / 20
I108 = Sum(abs(B108:G108 - 20))
J108: Max[B108:G108] - Min[B108:G108]
K108 = Max(abs(B108:G108 - 20))
L108: CountIf[x < 11, B108:G108] + CountIf[x > 29, B108:G108]
A109 = Sequence(Random[1, 6], k, 1, 120)
C109 = CountIf(x ≟ 2, A109)
D109 = CountIf(x ≟ 3, A109)
E109 = CountIf(x ≟ 4, A109)
F109 = CountIf(x ≟ 5, A109)
G109 = CountIf(x ≟ 6, A109)
B109 = CountIf(x ≟ 1, A109)
H109: (B109 - 20)^(2) / 20 + (C109 - 20)^(2) / 20 + (D109 - 20)^(2) / 20 + (E109 - 20)^(2) / 20 + (F109 - 20)^(2) / 20 + (G109 - 20)^(2) / 20
I109 = Sum(abs(B109:G109 - 20))
J109: Max[B109:G109] - Min[B109:G109]
K109 = Max(abs(B109:G109 - 20))
L109: CountIf[x < 11, B109:G109] + CountIf[x > 29, B109:G109]
A110 = Sequence(Random[1, 6], k, 1, 120)
C110 = CountIf(x ≟ 2, A110)
D110 = CountIf(x ≟ 3, A110)
E110 = CountIf(x ≟ 4, A110)
F110 = CountIf(x ≟ 5, A110)
G110 = CountIf(x ≟ 6, A110)
B110 = CountIf(x ≟ 1, A110)
H110: (B110 - 20)^(2) / 20 + (C110 - 20)^(2) / 20 + (D110 - 20)^(2) / 20 + (E110 - 20)^(2) / 20 + (F110 - 20)^(2) / 20 + (G110 - 20)^(2) / 20
I110 = Sum(abs(B110:G110 - 20))
J110: Max[B110:G110] - Min[B110:G110]
K110 = Max(abs(B110:G110 - 20))
L110: CountIf[x < 11, B110:G110] + CountIf[x > 29, B110:G110]
A111 = Sequence(Random[1, 6], k, 1, 120)
C111 = CountIf(x ≟ 2, A111)
D111 = CountIf(x ≟ 3, A111)
E111 = CountIf(x ≟ 4, A111)
F111 = CountIf(x ≟ 5, A111)
G111 = CountIf(x ≟ 6, A111)
B111 = CountIf(x ≟ 1, A111)
H111: (B111 - 20)^(2) / 20 + (C111 - 20)^(2) / 20 + (D111 - 20)^(2) / 20 + (E111 - 20)^(2) / 20 + (F111 - 20)^(2) / 20 + (G111 - 20)^(2) / 20
I111 = Sum(abs(B111:G111 - 20))
J111: Max[B111:G111] - Min[B111:G111]
K111 = Max(abs(B111:G111 - 20))
L111: CountIf[x < 11, B111:G111] + CountIf[x > 29, B111:G111]
A112 = Sequence(Random[1, 6], k, 1, 120)
C112 = CountIf(x ≟ 2, A112)
D112 = CountIf(x ≟ 3, A112)
E112 = CountIf(x ≟ 4, A112)
F112 = CountIf(x ≟ 5, A112)
G112 = CountIf(x ≟ 6, A112)
B112 = CountIf(x ≟ 1, A112)
H112: (B112 - 20)^(2) / 20 + (C112 - 20)^(2) / 20 + (D112 - 20)^(2) / 20 + (E112 - 20)^(2) / 20 + (F112 - 20)^(2) / 20 + (G112 - 20)^(2) / 20
I112 = Sum(abs(B112:G112 - 20))
J112: Max[B112:G112] - Min[B112:G112]
K112 = Max(abs(B112:G112 - 20))
L112: CountIf[x < 11, B112:G112] + CountIf[x > 29, B112:G112]
A113 = Sequence(Random[1, 6], k, 1, 120)
C113 = CountIf(x ≟ 2, A113)
D113 = CountIf(x ≟ 3, A113)
E113 = CountIf(x ≟ 4, A113)
F113 = CountIf(x ≟ 5, A113)
G113 = CountIf(x ≟ 6, A113)
B113 = CountIf(x ≟ 1, A113)
H113: (B113 - 20)^(2) / 20 + (C113 - 20)^(2) / 20 + (D113 - 20)^(2) / 20 + (E113 - 20)^(2) / 20 + (F113 - 20)^(2) / 20 + (G113 - 20)^(2) / 20
I113 = Sum(abs(B113:G113 - 20))
J113: Max[B113:G113] - Min[B113:G113]
K113 = Max(abs(B113:G113 - 20))
L113: CountIf[x < 11, B113:G113] + CountIf[x > 29, B113:G113]
A114 = Sequence(Random[1, 6], k, 1, 120)
C114 = CountIf(x ≟ 2, A114)
D114 = CountIf(x ≟ 3, A114)
E114 = CountIf(x ≟ 4, A114)
F114 = CountIf(x ≟ 5, A114)
G114 = CountIf(x ≟ 6, A114)
B114 = CountIf(x ≟ 1, A114)
H114: (B114 - 20)^(2) / 20 + (C114 - 20)^(2) / 20 + (D114 - 20)^(2) / 20 + (E114 - 20)^(2) / 20 + (F114 - 20)^(2) / 20 + (G114 - 20)^(2) / 20
I114 = Sum(abs(B114:G114 - 20))
J114: Max[B114:G114] - Min[B114:G114]
K114 = Max(abs(B114:G114 - 20))
L114: CountIf[x < 11, B114:G114] + CountIf[x > 29, B114:G114]
A115 = Sequence(Random[1, 6], k, 1, 120)
C115 = CountIf(x ≟ 2, A115)
D115 = CountIf(x ≟ 3, A115)
E115 = CountIf(x ≟ 4, A115)
F115 = CountIf(x ≟ 5, A115)
G115 = CountIf(x ≟ 6, A115)
B115 = CountIf(x ≟ 1, A115)
H115: (B115 - 20)^(2) / 20 + (C115 - 20)^(2) / 20 + (D115 - 20)^(2) / 20 + (E115 - 20)^(2) / 20 + (F115 - 20)^(2) / 20 + (G115 - 20)^(2) / 20
I115 = Sum(abs(B115:G115 - 20))
J115: Max[B115:G115] - Min[B115:G115]
K115 = Max(abs(B115:G115 - 20))
L115: CountIf[x < 11, B115:G115] + CountIf[x > 29, B115:G115]
A116 = Sequence(Random[1, 6], k, 1, 120)
C116 = CountIf(x ≟ 2, A116)
D116 = CountIf(x ≟ 3, A116)
E116 = CountIf(x ≟ 4, A116)
F116 = CountIf(x ≟ 5, A116)
G116 = CountIf(x ≟ 6, A116)
B116 = CountIf(x ≟ 1, A116)
H116: (B116 - 20)^(2) / 20 + (C116 - 20)^(2) / 20 + (D116 - 20)^(2) / 20 + (E116 - 20)^(2) / 20 + (F116 - 20)^(2) / 20 + (G116 - 20)^(2) / 20
I116 = Sum(abs(B116:G116 - 20))
J116: Max[B116:G116] - Min[B116:G116]
K116 = Max(abs(B116:G116 - 20))
L116: CountIf[x < 11, B116:G116] + CountIf[x > 29, B116:G116]
A117 = Sequence(Random[1, 6], k, 1, 120)
C117 = CountIf(x ≟ 2, A117)
D117 = CountIf(x ≟ 3, A117)
E117 = CountIf(x ≟ 4, A117)
F117 = CountIf(x ≟ 5, A117)
G117 = CountIf(x ≟ 6, A117)
B117 = CountIf(x ≟ 1, A117)
H117: (B117 - 20)^(2) / 20 + (C117 - 20)^(2) / 20 + (D117 - 20)^(2) / 20 + (E117 - 20)^(2) / 20 + (F117 - 20)^(2) / 20 + (G117 - 20)^(2) / 20
I117 = Sum(abs(B117:G117 - 20))
J117: Max[B117:G117] - Min[B117:G117]
K117 = Max(abs(B117:G117 - 20))
L117: CountIf[x < 11, B117:G117] + CountIf[x > 29, B117:G117]
A118 = Sequence(Random[1, 6], k, 1, 120)
C118 = CountIf(x ≟ 2, A118)
D118 = CountIf(x ≟ 3, A118)
E118 = CountIf(x ≟ 4, A118)
F118 = CountIf(x ≟ 5, A118)
G118 = CountIf(x ≟ 6, A118)
B118 = CountIf(x ≟ 1, A118)
H118: (B118 - 20)^(2) / 20 + (C118 - 20)^(2) / 20 + (D118 - 20)^(2) / 20 + (E118 - 20)^(2) / 20 + (F118 - 20)^(2) / 20 + (G118 - 20)^(2) / 20
I118 = Sum(abs(B118:G118 - 20))
J118: Max[B118:G118] - Min[B118:G118]
K118 = Max(abs(B118:G118 - 20))
L118: CountIf[x < 11, B118:G118] + CountIf[x > 29, B118:G118]
A119 = Sequence(Random[1, 6], k, 1, 120)
C119 = CountIf(x ≟ 2, A119)
D119 = CountIf(x ≟ 3, A119)
E119 = CountIf(x ≟ 4, A119)
F119 = CountIf(x ≟ 5, A119)
G119 = CountIf(x ≟ 6, A119)
B119 = CountIf(x ≟ 1, A119)
H119: (B119 - 20)^(2) / 20 + (C119 - 20)^(2) / 20 + (D119 - 20)^(2) / 20 + (E119 - 20)^(2) / 20 + (F119 - 20)^(2) / 20 + (G119 - 20)^(2) / 20
I119 = Sum(abs(B119:G119 - 20))
J119: Max[B119:G119] - Min[B119:G119]
K119 = Max(abs(B119:G119 - 20))
L119: CountIf[x < 11, B119:G119] + CountIf[x > 29, B119:G119]
A120 = Sequence(Random[1, 6], k, 1, 120)
C120 = CountIf(x ≟ 2, A120)
D120 = CountIf(x ≟ 3, A120)
E120 = CountIf(x ≟ 4, A120)
F120 = CountIf(x ≟ 5, A120)
G120 = CountIf(x ≟ 6, A120)
B120 = CountIf(x ≟ 1, A120)
H120: (B120 - 20)^(2) / 20 + (C120 - 20)^(2) / 20 + (D120 - 20)^(2) / 20 + (E120 - 20)^(2) / 20 + (F120 - 20)^(2) / 20 + (G120 - 20)^(2) / 20
I120 = Sum(abs(B120:G120 - 20))
J120: Max[B120:G120] - Min[B120:G120]
K120 = Max(abs(B120:G120 - 20))
L120: CountIf[x < 11, B120:G120] + CountIf[x > 29, B120:G120]
A121 = Sequence(Random[1, 6], k, 1, 120)
C121 = CountIf(x ≟ 2, A121)
D121 = CountIf(x ≟ 3, A121)
E121 = CountIf(x ≟ 4, A121)
F121 = CountIf(x ≟ 5, A121)
G121 = CountIf(x ≟ 6, A121)
B121 = CountIf(x ≟ 1, A121)
H121: (B121 - 20)^(2) / 20 + (C121 - 20)^(2) / 20 + (D121 - 20)^(2) / 20 + (E121 - 20)^(2) / 20 + (F121 - 20)^(2) / 20 + (G121 - 20)^(2) / 20
I121 = Sum(abs(B121:G121 - 20))
J121: Max[B121:G121] - Min[B121:G121]
K121 = Max(abs(B121:G121 - 20))
L121: CountIf[x < 11, B121:G121] + CountIf[x > 29, B121:G121]
I122 = Sum(abs(B122:G122 - 20))
J122: Max[B122:G122] - Min[B122:G122]
K122 = Max(abs(B122:G122 - 20))
L122: CountIf[x < 11, B122:G122] + CountIf[x > 29, B122:G122]
A123 = Sequence(Random[1, 6], k, 1, 120)
C123 = CountIf(x ≟ 2, A123)
D123 = CountIf(x ≟ 3, A123)
E123 = CountIf(x ≟ 4, A123)
F123 = CountIf(x ≟ 5, A123)
G123 = CountIf(x ≟ 6, A123)
B123 = CountIf(x ≟ 1, A123)
H123: (B123 - 20)^(2) / 20 + (C123 - 20)^(2) / 20 + (D123 - 20)^(2) / 20 + (E123 - 20)^(2) / 20 + (F123 - 20)^(2) / 20 + (G123 - 20)^(2) / 20
I123 = Sum(abs(B123:G123 - 20))
J123: Max[B123:G123] - Min[B123:G123]
K123 = Max(abs(B123:G123 - 20))
L123: CountIf[x < 11, B123:G123] + CountIf[x > 29, B123:G123]
A124 = Sequence(Random[1, 6], k, 1, 120)
C124 = CountIf(x ≟ 2, A124)
D124 = CountIf(x ≟ 3, A124)
E124 = CountIf(x ≟ 4, A124)
F124 = CountIf(x ≟ 5, A124)
G124 = CountIf(x ≟ 6, A124)
B124 = CountIf(x ≟ 1, A124)
H124: (B124 - 20)^(2) / 20 + (C124 - 20)^(2) / 20 + (D124 - 20)^(2) / 20 + (E124 - 20)^(2) / 20 + (F124 - 20)^(2) / 20 + (G124 - 20)^(2) / 20
I124 = Sum(abs(B124:G124 - 20))
J124: Max[B124:G124] - Min[B124:G124]
K124 = Max(abs(B124:G124 - 20))
L124: CountIf[x < 11, B124:G124] + CountIf[x > 29, B124:G124]
A125 = Sequence(Random[1, 6], k, 1, 120)
C125 = CountIf(x ≟ 2, A125)
D125 = CountIf(x ≟ 3, A125)
E125 = CountIf(x ≟ 4, A125)
F125 = CountIf(x ≟ 5, A125)
G125 = CountIf(x ≟ 6, A125)
B125 = CountIf(x ≟ 1, A125)
H125: (B125 - 20)^(2) / 20 + (C125 - 20)^(2) / 20 + (D125 - 20)^(2) / 20 + (E125 - 20)^(2) / 20 + (F125 - 20)^(2) / 20 + (G125 - 20)^(2) / 20
I125 = Sum(abs(B125:G125 - 20))
J125: Max[B125:G125] - Min[B125:G125]
K125 = Max(abs(B125:G125 - 20))
L125: CountIf[x < 11, B125:G125] + CountIf[x > 29, B125:G125]
A126 = Sequence(Random[1, 6], k, 1, 120)
C126 = CountIf(x ≟ 2, A126)
D126 = CountIf(x ≟ 3, A126)
E126 = CountIf(x ≟ 4, A126)
F126 = CountIf(x ≟ 5, A126)
G126 = CountIf(x ≟ 6, A126)
B126 = CountIf(x ≟ 1, A126)
H126: (B126 - 20)^(2) / 20 + (C126 - 20)^(2) / 20 + (D126 - 20)^(2) / 20 + (E126 - 20)^(2) / 20 + (F126 - 20)^(2) / 20 + (G126 - 20)^(2) / 20
I126 = Sum(abs(B126:G126 - 20))
J126: Max[B126:G126] - Min[B126:G126]
K126 = Max(abs(B126:G126 - 20))
L126: CountIf[x < 11, B126:G126] + CountIf[x > 29, B126:G126]
A127 = Sequence(Random[1, 6], k, 1, 120)
C127 = CountIf(x ≟ 2, A127)
D127 = CountIf(x ≟ 3, A127)
E127 = CountIf(x ≟ 4, A127)
F127 = CountIf(x ≟ 5, A127)
G127 = CountIf(x ≟ 6, A127)
B127 = CountIf(x ≟ 1, A127)
H127: (B127 - 20)^(2) / 20 + (C127 - 20)^(2) / 20 + (D127 - 20)^(2) / 20 + (E127 - 20)^(2) / 20 + (F127 - 20)^(2) / 20 + (G127 - 20)^(2) / 20
I127 = Sum(abs(B127:G127 - 20))
J127: Max[B127:G127] - Min[B127:G127]
K127 = Max(abs(B127:G127 - 20))
L127: CountIf[x < 11, B127:G127] + CountIf[x > 29, B127:G127]
A128 = Sequence(Random[1, 6], k, 1, 120)
C128 = CountIf(x ≟ 2, A128)
D128 = CountIf(x ≟ 3, A128)
E128 = CountIf(x ≟ 4, A128)
F128 = CountIf(x ≟ 5, A128)
G128 = CountIf(x ≟ 6, A128)
B128 = CountIf(x ≟ 1, A128)
H128: (B128 - 20)^(2) / 20 + (C128 - 20)^(2) / 20 + (D128 - 20)^(2) / 20 + (E128 - 20)^(2) / 20 + (F128 - 20)^(2) / 20 + (G128 - 20)^(2) / 20
I128 = Sum(abs(B128:G128 - 20))
J128: Max[B128:G128] - Min[B128:G128]
K128 = Max(abs(B128:G128 - 20))
L128: CountIf[x < 11, B128:G128] + CountIf[x > 29, B128:G128]
A129 = Sequence(Random[1, 6], k, 1, 120)
C129 = CountIf(x ≟ 2, A129)
D129 = CountIf(x ≟ 3, A129)
E129 = CountIf(x ≟ 4, A129)
F129 = CountIf(x ≟ 5, A129)
G129 = CountIf(x ≟ 6, A129)
B129 = CountIf(x ≟ 1, A129)
H129: (B129 - 20)^(2) / 20 + (C129 - 20)^(2) / 20 + (D129 - 20)^(2) / 20 + (E129 - 20)^(2) / 20 + (F129 - 20)^(2) / 20 + (G129 - 20)^(2) / 20
I129 = Sum(abs(B129:G129 - 20))
J129: Max[B129:G129] - Min[B129:G129]
K129 = Max(abs(B129:G129 - 20))
L129: CountIf[x < 11, B129:G129] + CountIf[x > 29, B129:G129]
A130 = Sequence(Random[1, 6], k, 1, 120)
C130 = CountIf(x ≟ 2, A130)
D130 = CountIf(x ≟ 3, A130)
E130 = CountIf(x ≟ 4, A130)
F130 = CountIf(x ≟ 5, A130)
G130 = CountIf(x ≟ 6, A130)
B130 = CountIf(x ≟ 1, A130)
H130: (B130 - 20)^(2) / 20 + (C130 - 20)^(2) / 20 + (D130 - 20)^(2) / 20 + (E130 - 20)^(2) / 20 + (F130 - 20)^(2) / 20 + (G130 - 20)^(2) / 20
I130 = Sum(abs(B130:G130 - 20))
J130: Max[B130:G130] - Min[B130:G130]
K130 = Max(abs(B130:G130 - 20))
L130: CountIf[x < 11, B130:G130] + CountIf[x > 29, B130:G130]
A131 = Sequence(Random[1, 6], k, 1, 120)
C131 = CountIf(x ≟ 2, A131)
D131 = CountIf(x ≟ 3, A131)
E131 = CountIf(x ≟ 4, A131)
F131 = CountIf(x ≟ 5, A131)
G131 = CountIf(x ≟ 6, A131)
B131 = CountIf(x ≟ 1, A131)
H131: (B131 - 20)^(2) / 20 + (C131 - 20)^(2) / 20 + (D131 - 20)^(2) / 20 + (E131 - 20)^(2) / 20 + (F131 - 20)^(2) / 20 + (G131 - 20)^(2) / 20
I131 = Sum(abs(B131:G131 - 20))
J131: Max[B131:G131] - Min[B131:G131]
K131 = Max(abs(B131:G131 - 20))
L131: CountIf[x < 11, B131:G131] + CountIf[x > 29, B131:G131]
A132 = Sequence(Random[1, 6], k, 1, 120)
C132 = CountIf(x ≟ 2, A132)
D132 = CountIf(x ≟ 3, A132)
E132 = CountIf(x ≟ 4, A132)
F132 = CountIf(x ≟ 5, A132)
G132 = CountIf(x ≟ 6, A132)
B132 = CountIf(x ≟ 1, A132)
H132: (B132 - 20)^(2) / 20 + (C132 - 20)^(2) / 20 + (D132 - 20)^(2) / 20 + (E132 - 20)^(2) / 20 + (F132 - 20)^(2) / 20 + (G132 - 20)^(2) / 20
I132 = Sum(abs(B132:G132 - 20))
J132: Max[B132:G132] - Min[B132:G132]
K132 = Max(abs(B132:G132 - 20))
L132: CountIf[x < 11, B132:G132] + CountIf[x > 29, B132:G132]
A133 = Sequence(Random[1, 6], k, 1, 120)
C133 = CountIf(x ≟ 2, A133)
D133 = CountIf(x ≟ 3, A133)
E133 = CountIf(x ≟ 4, A133)
F133 = CountIf(x ≟ 5, A133)
G133 = CountIf(x ≟ 6, A133)
B133 = CountIf(x ≟ 1, A133)
H133: (B133 - 20)^(2) / 20 + (C133 - 20)^(2) / 20 + (D133 - 20)^(2) / 20 + (E133 - 20)^(2) / 20 + (F133 - 20)^(2) / 20 + (G133 - 20)^(2) / 20
I133 = Sum(abs(B133:G133 - 20))
J133: Max[B133:G133] - Min[B133:G133]
K133 = Max(abs(B133:G133 - 20))
L133: CountIf[x < 11, B133:G133] + CountIf[x > 29, B133:G133]
A134 = Sequence(Random[1, 6], k, 1, 120)
C134 = CountIf(x ≟ 2, A134)
D134 = CountIf(x ≟ 3, A134)
E134 = CountIf(x ≟ 4, A134)
F134 = CountIf(x ≟ 5, A134)
G134 = CountIf(x ≟ 6, A134)
B134 = CountIf(x ≟ 1, A134)
H134: (B134 - 20)^(2) / 20 + (C134 - 20)^(2) / 20 + (D134 - 20)^(2) / 20 + (E134 - 20)^(2) / 20 + (F134 - 20)^(2) / 20 + (G134 - 20)^(2) / 20
I134 = Sum(abs(B134:G134 - 20))
J134: Max[B134:G134] - Min[B134:G134]
K134 = Max(abs(B134:G134 - 20))
L134: CountIf[x < 11, B134:G134] + CountIf[x > 29, B134:G134]
A135 = Sequence(Random[1, 6], k, 1, 120)
C135 = CountIf(x ≟ 2, A135)
D135 = CountIf(x ≟ 3, A135)
E135 = CountIf(x ≟ 4, A135)
F135 = CountIf(x ≟ 5, A135)
G135 = CountIf(x ≟ 6, A135)
B135 = CountIf(x ≟ 1, A135)
H135: (B135 - 20)^(2) / 20 + (C135 - 20)^(2) / 20 + (D135 - 20)^(2) / 20 + (E135 - 20)^(2) / 20 + (F135 - 20)^(2) / 20 + (G135 - 20)^(2) / 20
I135 = Sum(abs(B135:G135 - 20))
J135: Max[B135:G135] - Min[B135:G135]
K135 = Max(abs(B135:G135 - 20))
L135: CountIf[x < 11, B135:G135] + CountIf[x > 29, B135:G135]
A136 = Sequence(Random[1, 6], k, 1, 120)
C136 = CountIf(x ≟ 2, A136)
D136 = CountIf(x ≟ 3, A136)
E136 = CountIf(x ≟ 4, A136)
F136 = CountIf(x ≟ 5, A136)
G136 = CountIf(x ≟ 6, A136)
B136 = CountIf(x ≟ 1, A136)
H136: (B136 - 20)^(2) / 20 + (C136 - 20)^(2) / 20 + (D136 - 20)^(2) / 20 + (E136 - 20)^(2) / 20 + (F136 - 20)^(2) / 20 + (G136 - 20)^(2) / 20
I136 = Sum(abs(B136:G136 - 20))
J136: Max[B136:G136] - Min[B136:G136]
K136 = Max(abs(B136:G136 - 20))
L136: CountIf[x < 11, B136:G136] + CountIf[x > 29, B136:G136]
A137 = Sequence(Random[1, 6], k, 1, 120)
C137 = CountIf(x ≟ 2, A137)
D137 = CountIf(x ≟ 3, A137)
E137 = CountIf(x ≟ 4, A137)
F137 = CountIf(x ≟ 5, A137)
G137 = CountIf(x ≟ 6, A137)
B137 = CountIf(x ≟ 1, A137)
H137: (B137 - 20)^(2) / 20 + (C137 - 20)^(2) / 20 + (D137 - 20)^(2) / 20 + (E137 - 20)^(2) / 20 + (F137 - 20)^(2) / 20 + (G137 - 20)^(2) / 20
I137 = Sum(abs(B137:G137 - 20))
J137: Max[B137:G137] - Min[B137:G137]
K137 = Max(abs(B137:G137 - 20))
L137: CountIf[x < 11, B137:G137] + CountIf[x > 29, B137:G137]
A138 = Sequence(Random[1, 6], k, 1, 120)
C138 = CountIf(x ≟ 2, A138)
D138 = CountIf(x ≟ 3, A138)
E138 = CountIf(x ≟ 4, A138)
F138 = CountIf(x ≟ 5, A138)
G138 = CountIf(x ≟ 6, A138)
B138 = CountIf(x ≟ 1, A138)
H138: (B138 - 20)^(2) / 20 + (C138 - 20)^(2) / 20 + (D138 - 20)^(2) / 20 + (E138 - 20)^(2) / 20 + (F138 - 20)^(2) / 20 + (G138 - 20)^(2) / 20
I138 = Sum(abs(B138:G138 - 20))
J138: Max[B138:G138] - Min[B138:G138]
K138 = Max(abs(B138:G138 - 20))
L138: CountIf[x < 11, B138:G138] + CountIf[x > 29, B138:G138]
A139 = Sequence(Random[1, 6], k, 1, 120)
C139 = CountIf(x ≟ 2, A139)
D139 = CountIf(x ≟ 3, A139)
E139 = CountIf(x ≟ 4, A139)
F139 = CountIf(x ≟ 5, A139)
G139 = CountIf(x ≟ 6, A139)
B139 = CountIf(x ≟ 1, A139)
H139: (B139 - 20)^(2) / 20 + (C139 - 20)^(2) / 20 + (D139 - 20)^(2) / 20 + (E139 - 20)^(2) / 20 + (F139 - 20)^(2) / 20 + (G139 - 20)^(2) / 20
I139 = Sum(abs(B139:G139 - 20))
J139: Max[B139:G139] - Min[B139:G139]
K139 = Max(abs(B139:G139 - 20))
L139: CountIf[x < 11, B139:G139] + CountIf[x > 29, B139:G139]
A140 = Sequence(Random[1, 6], k, 1, 120)
C140 = CountIf(x ≟ 2, A140)
D140 = CountIf(x ≟ 3, A140)
E140 = CountIf(x ≟ 4, A140)
F140 = CountIf(x ≟ 5, A140)
G140 = CountIf(x ≟ 6, A140)
B140 = CountIf(x ≟ 1, A140)
H140: (B140 - 20)^(2) / 20 + (C140 - 20)^(2) / 20 + (D140 - 20)^(2) / 20 + (E140 - 20)^(2) / 20 + (F140 - 20)^(2) / 20 + (G140 - 20)^(2) / 20
I140 = Sum(abs(B140:G140 - 20))
J140: Max[B140:G140] - Min[B140:G140]
K140 = Max(abs(B140:G140 - 20))
L140: CountIf[x < 11, B140:G140] + CountIf[x > 29, B140:G140]
A141 = Sequence(Random[1, 6], k, 1, 120)
C141 = CountIf(x ≟ 2, A141)
D141 = CountIf(x ≟ 3, A141)
E141 = CountIf(x ≟ 4, A141)
F141 = CountIf(x ≟ 5, A141)
G141 = CountIf(x ≟ 6, A141)
B141 = CountIf(x ≟ 1, A141)
H141: (B141 - 20)^(2) / 20 + (C141 - 20)^(2) / 20 + (D141 - 20)^(2) / 20 + (E141 - 20)^(2) / 20 + (F141 - 20)^(2) / 20 + (G141 - 20)^(2) / 20
I141 = Sum(abs(B141:G141 - 20))
J141: Max[B141:G141] - Min[B141:G141]
K141 = Max(abs(B141:G141 - 20))
L141: CountIf[x < 11, B141:G141] + CountIf[x > 29, B141:G141]
A142 = Sequence(Random[1, 6], k, 1, 120)
C142 = CountIf(x ≟ 2, A142)
D142 = CountIf(x ≟ 3, A142)
E142 = CountIf(x ≟ 4, A142)
F142 = CountIf(x ≟ 5, A142)
G142 = CountIf(x ≟ 6, A142)
B142 = CountIf(x ≟ 1, A142)
H142: (B142 - 20)^(2) / 20 + (C142 - 20)^(2) / 20 + (D142 - 20)^(2) / 20 + (E142 - 20)^(2) / 20 + (F142 - 20)^(2) / 20 + (G142 - 20)^(2) / 20
I142 = Sum(abs(B142:G142 - 20))
J142: Max[B142:G142] - Min[B142:G142]
K142 = Max(abs(B142:G142 - 20))
L142: CountIf[x < 11, B142:G142] + CountIf[x > 29, B142:G142]
A143 = Sequence(Random[1, 6], k, 1, 120)
C143 = CountIf(x ≟ 2, A143)
D143 = CountIf(x ≟ 3, A143)
E143 = CountIf(x ≟ 4, A143)
F143 = CountIf(x ≟ 5, A143)
G143 = CountIf(x ≟ 6, A143)
B143 = CountIf(x ≟ 1, A143)
H143: (B143 - 20)^(2) / 20 + (C143 - 20)^(2) / 20 + (D143 - 20)^(2) / 20 + (E143 - 20)^(2) / 20 + (F143 - 20)^(2) / 20 + (G143 - 20)^(2) / 20
I143 = Sum(abs(B143:G143 - 20))
J143: Max[B143:G143] - Min[B143:G143]
K143 = Max(abs(B143:G143 - 20))
L143: CountIf[x < 11, B143:G143] + CountIf[x > 29, B143:G143]
A144 = Sequence(Random[1, 6], k, 1, 120)
C144 = CountIf(x ≟ 2, A144)
D144 = CountIf(x ≟ 3, A144)
E144 = CountIf(x ≟ 4, A144)
F144 = CountIf(x ≟ 5, A144)
G144 = CountIf(x ≟ 6, A144)
B144 = CountIf(x ≟ 1, A144)
H144: (B144 - 20)^(2) / 20 + (C144 - 20)^(2) / 20 + (D144 - 20)^(2) / 20 + (E144 - 20)^(2) / 20 + (F144 - 20)^(2) / 20 + (G144 - 20)^(2) / 20
I144 = Sum(abs(B144:G144 - 20))
J144: Max[B144:G144] - Min[B144:G144]
K144 = Max(abs(B144:G144 - 20))
L144: CountIf[x < 11, B144:G144] + CountIf[x > 29, B144:G144]
A145 = Sequence(Random[1, 6], k, 1, 120)
C145 = CountIf(x ≟ 2, A145)
D145 = CountIf(x ≟ 3, A145)
E145 = CountIf(x ≟ 4, A145)
F145 = CountIf(x ≟ 5, A145)
G145 = CountIf(x ≟ 6, A145)
B145 = CountIf(x ≟ 1, A145)
H145: (B145 - 20)^(2) / 20 + (C145 - 20)^(2) / 20 + (D145 - 20)^(2) / 20 + (E145 - 20)^(2) / 20 + (F145 - 20)^(2) / 20 + (G145 - 20)^(2) / 20
I145 = Sum(abs(B145:G145 - 20))
J145: Max[B145:G145] - Min[B145:G145]
K145 = Max(abs(B145:G145 - 20))
L145: CountIf[x < 11, B145:G145] + CountIf[x > 29, B145:G145]
A146 = Sequence(Random[1, 6], k, 1, 120)
C146 = CountIf(x ≟ 2, A146)
D146 = CountIf(x ≟ 3, A146)
E146 = CountIf(x ≟ 4, A146)
F146 = CountIf(x ≟ 5, A146)
G146 = CountIf(x ≟ 6, A146)
B146 = CountIf(x ≟ 1, A146)
H146: (B146 - 20)^(2) / 20 + (C146 - 20)^(2) / 20 + (D146 - 20)^(2) / 20 + (E146 - 20)^(2) / 20 + (F146 - 20)^(2) / 20 + (G146 - 20)^(2) / 20
I146 = Sum(abs(B146:G146 - 20))
J146: Max[B146:G146] - Min[B146:G146]
K146 = Max(abs(B146:G146 - 20))
L146: CountIf[x < 11, B146:G146] + CountIf[x > 29, B146:G146]
A147 = Sequence(Random[1, 6], k, 1, 120)
C147 = CountIf(x ≟ 2, A147)
D147 = CountIf(x ≟ 3, A147)
E147 = CountIf(x ≟ 4, A147)
F147 = CountIf(x ≟ 5, A147)
G147 = CountIf(x ≟ 6, A147)
B147 = CountIf(x ≟ 1, A147)
H147: (B147 - 20)^(2) / 20 + (C147 - 20)^(2) / 20 + (D147 - 20)^(2) / 20 + (E147 - 20)^(2) / 20 + (F147 - 20)^(2) / 20 + (G147 - 20)^(2) / 20
I147 = Sum(abs(B147:G147 - 20))
J147: Max[B147:G147] - Min[B147:G147]
K147 = Max(abs(B147:G147 - 20))
L147: CountIf[x < 11, B147:G147] + CountIf[x > 29, B147:G147]
A148 = Sequence(Random[1, 6], k, 1, 120)
C148 = CountIf(x ≟ 2, A148)
D148 = CountIf(x ≟ 3, A148)
E148 = CountIf(x ≟ 4, A148)
F148 = CountIf(x ≟ 5, A148)
G148 = CountIf(x ≟ 6, A148)
B148 = CountIf(x ≟ 1, A148)
H148: (B148 - 20)^(2) / 20 + (C148 - 20)^(2) / 20 + (D148 - 20)^(2) / 20 + (E148 - 20)^(2) / 20 + (F148 - 20)^(2) / 20 + (G148 - 20)^(2) / 20
I148 = Sum(abs(B148:G148 - 20))
J148: Max[B148:G148] - Min[B148:G148]
K148 = Max(abs(B148:G148 - 20))
L148: CountIf[x < 11, B148:G148] + CountIf[x > 29, B148:G148]
A149 = Sequence(Random[1, 6], k, 1, 120)
C149 = CountIf(x ≟ 2, A149)
D149 = CountIf(x ≟ 3, A149)
E149 = CountIf(x ≟ 4, A149)
F149 = CountIf(x ≟ 5, A149)
G149 = CountIf(x ≟ 6, A149)
B149 = CountIf(x ≟ 1, A149)
H149: (B149 - 20)^(2) / 20 + (C149 - 20)^(2) / 20 + (D149 - 20)^(2) / 20 + (E149 - 20)^(2) / 20 + (F149 - 20)^(2) / 20 + (G149 - 20)^(2) / 20
I149 = Sum(abs(B149:G149 - 20))
J149: Max[B149:G149] - Min[B149:G149]
K149 = Max(abs(B149:G149 - 20))
L149: CountIf[x < 11, B149:G149] + CountIf[x > 29, B149:G149]
A150 = Sequence(Random[1, 6], k, 1, 120)
C150 = CountIf(x ≟ 2, A150)
D150 = CountIf(x ≟ 3, A150)
E150 = CountIf(x ≟ 4, A150)
F150 = CountIf(x ≟ 5, A150)
G150 = CountIf(x ≟ 6, A150)
B150 = CountIf(x ≟ 1, A150)
H150: (B150 - 20)^(2) / 20 + (C150 - 20)^(2) / 20 + (D150 - 20)^(2) / 20 + (E150 - 20)^(2) / 20 + (F150 - 20)^(2) / 20 + (G150 - 20)^(2) / 20
I150 = Sum(abs(B150:G150 - 20))
J150: Max[B150:G150] - Min[B150:G150]
K150 = Max(abs(B150:G150 - 20))
L150: CountIf[x < 11, B150:G150] + CountIf[x > 29, B150:G150]
A151 = Sequence(Random[1, 6], k, 1, 120)
C151 = CountIf(x ≟ 2, A151)
D151 = CountIf(x ≟ 3, A151)
E151 = CountIf(x ≟ 4, A151)
F151 = CountIf(x ≟ 5, A151)
G151 = CountIf(x ≟ 6, A151)
B151 = CountIf(x ≟ 1, A151)
H151: (B151 - 20)^(2) / 20 + (C151 - 20)^(2) / 20 + (D151 - 20)^(2) / 20 + (E151 - 20)^(2) / 20 + (F151 - 20)^(2) / 20 + (G151 - 20)^(2) / 20
I151 = Sum(abs(B151:G151 - 20))
J151: Max[B151:G151] - Min[B151:G151]
K151 = Max(abs(B151:G151 - 20))
L151: CountIf[x < 11, B151:G151] + CountIf[x > 29, B151:G151]
A152 = Sequence(Random[1, 6], k, 1, 120)
C152 = CountIf(x ≟ 2, A152)
D152 = CountIf(x ≟ 3, A152)
E152 = CountIf(x ≟ 4, A152)
F152 = CountIf(x ≟ 5, A152)
G152 = CountIf(x ≟ 6, A152)
B152 = CountIf(x ≟ 1, A152)
H152: (B152 - 20)^(2) / 20 + (C152 - 20)^(2) / 20 + (D152 - 20)^(2) / 20 + (E152 - 20)^(2) / 20 + (F152 - 20)^(2) / 20 + (G152 - 20)^(2) / 20
I152 = Sum(abs(B152:G152 - 20))
J152: Max[B152:G152] - Min[B152:G152]
K152 = Max(abs(B152:G152 - 20))
L152: CountIf[x < 11, B152:G152] + CountIf[x > 29, B152:G152]
A153 = Sequence(Random[1, 6], k, 1, 120)
C153 = CountIf(x ≟ 2, A153)
D153 = CountIf(x ≟ 3, A153)
E153 = CountIf(x ≟ 4, A153)
F153 = CountIf(x ≟ 5, A153)
G153 = CountIf(x ≟ 6, A153)
B153 = CountIf(x ≟ 1, A153)
H153: (B153 - 20)^(2) / 20 + (C153 - 20)^(2) / 20 + (D153 - 20)^(2) / 20 + (E153 - 20)^(2) / 20 + (F153 - 20)^(2) / 20 + (G153 - 20)^(2) / 20
I153 = Sum(abs(B153:G153 - 20))
J153: Max[B153:G153] - Min[B153:G153]
K153 = Max(abs(B153:G153 - 20))
L153: CountIf[x < 11, B153:G153] + CountIf[x > 29, B153:G153]
A154 = Sequence(Random[1, 6], k, 1, 120)
C154 = CountIf(x ≟ 2, A154)
D154 = CountIf(x ≟ 3, A154)
E154 = CountIf(x ≟ 4, A154)
F154 = CountIf(x ≟ 5, A154)
G154 = CountIf(x ≟ 6, A154)
B154 = CountIf(x ≟ 1, A154)
H154: (B154 - 20)^(2) / 20 + (C154 - 20)^(2) / 20 + (D154 - 20)^(2) / 20 + (E154 - 20)^(2) / 20 + (F154 - 20)^(2) / 20 + (G154 - 20)^(2) / 20
I154 = Sum(abs(B154:G154 - 20))
J154: Max[B154:G154] - Min[B154:G154]
K154 = Max(abs(B154:G154 - 20))
L154: CountIf[x < 11, B154:G154] + CountIf[x > 29, B154:G154]
A155 = Sequence(Random[1, 6], k, 1, 120)
C155 = CountIf(x ≟ 2, A155)
D155 = CountIf(x ≟ 3, A155)
E155 = CountIf(x ≟ 4, A155)
F155 = CountIf(x ≟ 5, A155)
G155 = CountIf(x ≟ 6, A155)
B155 = CountIf(x ≟ 1, A155)
H155: (B155 - 20)^(2) / 20 + (C155 - 20)^(2) / 20 + (D155 - 20)^(2) / 20 + (E155 - 20)^(2) / 20 + (F155 - 20)^(2) / 20 + (G155 - 20)^(2) / 20
I155 = Sum(abs(B155:G155 - 20))
J155: Max[B155:G155] - Min[B155:G155]
K155 = Max(abs(B155:G155 - 20))
L155: CountIf[x < 11, B155:G155] + CountIf[x > 29, B155:G155]
A156 = Sequence(Random[1, 6], k, 1, 120)
C156 = CountIf(x ≟ 2, A156)
D156 = CountIf(x ≟ 3, A156)
E156 = CountIf(x ≟ 4, A156)
F156 = CountIf(x ≟ 5, A156)
G156 = CountIf(x ≟ 6, A156)
B156 = CountIf(x ≟ 1, A156)
H156: (B156 - 20)^(2) / 20 + (C156 - 20)^(2) / 20 + (D156 - 20)^(2) / 20 + (E156 - 20)^(2) / 20 + (F156 - 20)^(2) / 20 + (G156 - 20)^(2) / 20
I156 = Sum(abs(B156:G156 - 20))
J156: Max[B156:G156] - Min[B156:G156]
K156 = Max(abs(B156:G156 - 20))
L156: CountIf[x < 11, B156:G156] + CountIf[x > 29, B156:G156]
A157 = Sequence(Random[1, 6], k, 1, 120)
C157 = CountIf(x ≟ 2, A157)
D157 = CountIf(x ≟ 3, A157)
E157 = CountIf(x ≟ 4, A157)
F157 = CountIf(x ≟ 5, A157)
G157 = CountIf(x ≟ 6, A157)
B157 = CountIf(x ≟ 1, A157)
H157: (B157 - 20)^(2) / 20 + (C157 - 20)^(2) / 20 + (D157 - 20)^(2) / 20 + (E157 - 20)^(2) / 20 + (F157 - 20)^(2) / 20 + (G157 - 20)^(2) / 20
I157 = Sum(abs(B157:G157 - 20))
J157: Max[B157:G157] - Min[B157:G157]
K157 = Max(abs(B157:G157 - 20))
L157: CountIf[x < 11, B157:G157] + CountIf[x > 29, B157:G157]
A158 = Sequence(Random[1, 6], k, 1, 120)
C158 = CountIf(x ≟ 2, A158)
D158 = CountIf(x ≟ 3, A158)
E158 = CountIf(x ≟ 4, A158)
F158 = CountIf(x ≟ 5, A158)
G158 = CountIf(x ≟ 6, A158)
B158 = CountIf(x ≟ 1, A158)
H158: (B158 - 20)^(2) / 20 + (C158 - 20)^(2) / 20 + (D158 - 20)^(2) / 20 + (E158 - 20)^(2) / 20 + (F158 - 20)^(2) / 20 + (G158 - 20)^(2) / 20
I158 = Sum(abs(B158:G158 - 20))
J158: Max[B158:G158] - Min[B158:G158]
K158 = Max(abs(B158:G158 - 20))
L158: CountIf[x < 11, B158:G158] + CountIf[x > 29, B158:G158]
A159 = Sequence(Random[1, 6], k, 1, 120)
C159 = CountIf(x ≟ 2, A159)
D159 = CountIf(x ≟ 3, A159)
E159 = CountIf(x ≟ 4, A159)
F159 = CountIf(x ≟ 5, A159)
G159 = CountIf(x ≟ 6, A159)
B159 = CountIf(x ≟ 1, A159)
H159: (B159 - 20)^(2) / 20 + (C159 - 20)^(2) / 20 + (D159 - 20)^(2) / 20 + (E159 - 20)^(2) / 20 + (F159 - 20)^(2) / 20 + (G159 - 20)^(2) / 20
I159 = Sum(abs(B159:G159 - 20))
J159: Max[B159:G159] - Min[B159:G159]
K159 = Max(abs(B159:G159 - 20))
L159: CountIf[x < 11, B159:G159] + CountIf[x > 29, B159:G159]
A160 = Sequence(Random[1, 6], k, 1, 120)
C160 = CountIf(x ≟ 2, A160)
D160 = CountIf(x ≟ 3, A160)
E160 = CountIf(x ≟ 4, A160)
F160 = CountIf(x ≟ 5, A160)
G160 = CountIf(x ≟ 6, A160)
B160 = CountIf(x ≟ 1, A160)
H160: (B160 - 20)^(2) / 20 + (C160 - 20)^(2) / 20 + (D160 - 20)^(2) / 20 + (E160 - 20)^(2) / 20 + (F160 - 20)^(2) / 20 + (G160 - 20)^(2) / 20
I160 = Sum(abs(B160:G160 - 20))
J160: Max[B160:G160] - Min[B160:G160]
K160 = Max(abs(B160:G160 - 20))
L160: CountIf[x < 11, B160:G160] + CountIf[x > 29, B160:G160]
A161 = Sequence(Random[1, 6], k, 1, 120)
C161 = CountIf(x ≟ 2, A161)
D161 = CountIf(x ≟ 3, A161)
E161 = CountIf(x ≟ 4, A161)
F161 = CountIf(x ≟ 5, A161)
G161 = CountIf(x ≟ 6, A161)
B161 = CountIf(x ≟ 1, A161)
H161: (B161 - 20)^(2) / 20 + (C161 - 20)^(2) / 20 + (D161 - 20)^(2) / 20 + (E161 - 20)^(2) / 20 + (F161 - 20)^(2) / 20 + (G161 - 20)^(2) / 20
I161 = Sum(abs(B161:G161 - 20))
J161: Max[B161:G161] - Min[B161:G161]
K161 = Max(abs(B161:G161 - 20))
L161: CountIf[x < 11, B161:G161] + CountIf[x > 29, B161:G161]
A162 = Sequence(Random[1, 6], k, 1, 120)
C162 = CountIf(x ≟ 2, A162)
D162 = CountIf(x ≟ 3, A162)
E162 = CountIf(x ≟ 4, A162)
F162 = CountIf(x ≟ 5, A162)
G162 = CountIf(x ≟ 6, A162)
B162 = CountIf(x ≟ 1, A162)
H162: (B162 - 20)^(2) / 20 + (C162 - 20)^(2) / 20 + (D162 - 20)^(2) / 20 + (E162 - 20)^(2) / 20 + (F162 - 20)^(2) / 20 + (G162 - 20)^(2) / 20
I162 = Sum(abs(B162:G162 - 20))
J162: Max[B162:G162] - Min[B162:G162]
K162 = Max(abs(B162:G162 - 20))
L162: CountIf[x < 11, B162:G162] + CountIf[x > 29, B162:G162]
A163 = Sequence(Random[1, 6], k, 1, 120)
C163 = CountIf(x ≟ 2, A163)
D163 = CountIf(x ≟ 3, A163)
E163 = CountIf(x ≟ 4, A163)
F163 = CountIf(x ≟ 5, A163)
G163 = CountIf(x ≟ 6, A163)
B163 = CountIf(x ≟ 1, A163)
H163: (B163 - 20)^(2) / 20 + (C163 - 20)^(2) / 20 + (D163 - 20)^(2) / 20 + (E163 - 20)^(2) / 20 + (F163 - 20)^(2) / 20 + (G163 - 20)^(2) / 20
I163 = Sum(abs(B163:G163 - 20))
J163: Max[B163:G163] - Min[B163:G163]
K163 = Max(abs(B163:G163 - 20))
L163: CountIf[x < 11, B163:G163] + CountIf[x > 29, B163:G163]
A164 = Sequence(Random[1, 6], k, 1, 120)
C164 = CountIf(x ≟ 2, A164)
D164 = CountIf(x ≟ 3, A164)
E164 = CountIf(x ≟ 4, A164)
F164 = CountIf(x ≟ 5, A164)
G164 = CountIf(x ≟ 6, A164)
B164 = CountIf(x ≟ 1, A164)
H164: (B164 - 20)^(2) / 20 + (C164 - 20)^(2) / 20 + (D164 - 20)^(2) / 20 + (E164 - 20)^(2) / 20 + (F164 - 20)^(2) / 20 + (G164 - 20)^(2) / 20
I164 = Sum(abs(B164:G164 - 20))
J164: Max[B164:G164] - Min[B164:G164]
K164 = Max(abs(B164:G164 - 20))
L164: CountIf[x < 11, B164:G164] + CountIf[x > 29, B164:G164]
A165 = Sequence(Random[1, 6], k, 1, 120)
C165 = CountIf(x ≟ 2, A165)
D165 = CountIf(x ≟ 3, A165)
E165 = CountIf(x ≟ 4, A165)
F165 = CountIf(x ≟ 5, A165)
G165 = CountIf(x ≟ 6, A165)
B165 = CountIf(x ≟ 1, A165)
H165: (B165 - 20)^(2) / 20 + (C165 - 20)^(2) / 20 + (D165 - 20)^(2) / 20 + (E165 - 20)^(2) / 20 + (F165 - 20)^(2) / 20 + (G165 - 20)^(2) / 20
I165 = Sum(abs(B165:G165 - 20))
J165: Max[B165:G165] - Min[B165:G165]
K165 = Max(abs(B165:G165 - 20))
L165: CountIf[x < 11, B165:G165] + CountIf[x > 29, B165:G165]
A166 = Sequence(Random[1, 6], k, 1, 120)
C166 = CountIf(x ≟ 2, A166)
D166 = CountIf(x ≟ 3, A166)
E166 = CountIf(x ≟ 4, A166)
F166 = CountIf(x ≟ 5, A166)
G166 = CountIf(x ≟ 6, A166)
B166 = CountIf(x ≟ 1, A166)
H166: (B166 - 20)^(2) / 20 + (C166 - 20)^(2) / 20 + (D166 - 20)^(2) / 20 + (E166 - 20)^(2) / 20 + (F166 - 20)^(2) / 20 + (G166 - 20)^(2) / 20
I166 = Sum(abs(B166:G166 - 20))
J166: Max[B166:G166] - Min[B166:G166]
K166 = Max(abs(B166:G166 - 20))
L166: CountIf[x < 11, B166:G166] + CountIf[x > 29, B166:G166]
A167 = Sequence(Random[1, 6], k, 1, 120)
C167 = CountIf(x ≟ 2, A167)
D167 = CountIf(x ≟ 3, A167)
E167 = CountIf(x ≟ 4, A167)
F167 = CountIf(x ≟ 5, A167)
G167 = CountIf(x ≟ 6, A167)
B167 = CountIf(x ≟ 1, A167)
H167: (B167 - 20)^(2) / 20 + (C167 - 20)^(2) / 20 + (D167 - 20)^(2) / 20 + (E167 - 20)^(2) / 20 + (F167 - 20)^(2) / 20 + (G167 - 20)^(2) / 20
I167 = Sum(abs(B167:G167 - 20))
J167: Max[B167:G167] - Min[B167:G167]
K167 = Max(abs(B167:G167 - 20))
L167: CountIf[x < 11, B167:G167] + CountIf[x > 29, B167:G167]
A168 = Sequence(Random[1, 6], k, 1, 120)
C168 = CountIf(x ≟ 2, A168)
D168 = CountIf(x ≟ 3, A168)
E168 = CountIf(x ≟ 4, A168)
F168 = CountIf(x ≟ 5, A168)
G168 = CountIf(x ≟ 6, A168)
B168 = CountIf(x ≟ 1, A168)
H168: (B168 - 20)^(2) / 20 + (C168 - 20)^(2) / 20 + (D168 - 20)^(2) / 20 + (E168 - 20)^(2) / 20 + (F168 - 20)^(2) / 20 + (G168 - 20)^(2) / 20
I168 = Sum(abs(B168:G168 - 20))
J168: Max[B168:G168] - Min[B168:G168]
K168 = Max(abs(B168:G168 - 20))
L168: CountIf[x < 11, B168:G168] + CountIf[x > 29, B168:G168]
A169 = Sequence(Random[1, 6], k, 1, 120)
C169 = CountIf(x ≟ 2, A169)
D169 = CountIf(x ≟ 3, A169)
E169 = CountIf(x ≟ 4, A169)
F169 = CountIf(x ≟ 5, A169)
G169 = CountIf(x ≟ 6, A169)
B169 = CountIf(x ≟ 1, A169)
H169: (B169 - 20)^(2) / 20 + (C169 - 20)^(2) / 20 + (D169 - 20)^(2) / 20 + (E169 - 20)^(2) / 20 + (F169 - 20)^(2) / 20 + (G169 - 20)^(2) / 20
I169 = Sum(abs(B169:G169 - 20))
J169: Max[B169:G169] - Min[B169:G169]
K169 = Max(abs(B169:G169 - 20))
L169: CountIf[x < 11, B169:G169] + CountIf[x > 29, B169:G169]
A170 = Sequence(Random[1, 6], k, 1, 120)
C170 = CountIf(x ≟ 2, A170)
D170 = CountIf(x ≟ 3, A170)
E170 = CountIf(x ≟ 4, A170)
F170 = CountIf(x ≟ 5, A170)
G170 = CountIf(x ≟ 6, A170)
B170 = CountIf(x ≟ 1, A170)
H170: (B170 - 20)^(2) / 20 + (C170 - 20)^(2) / 20 + (D170 - 20)^(2) / 20 + (E170 - 20)^(2) / 20 + (F170 - 20)^(2) / 20 + (G170 - 20)^(2) / 20
I170 = Sum(abs(B170:G170 - 20))
J170: Max[B170:G170] - Min[B170:G170]
K170 = Max(abs(B170:G170 - 20))
L170: CountIf[x < 11, B170:G170] + CountIf[x > 29, B170:G170]
A171 = Sequence(Random[1, 6], k, 1, 120)
C171 = CountIf(x ≟ 2, A171)
D171 = CountIf(x ≟ 3, A171)
E171 = CountIf(x ≟ 4, A171)
F171 = CountIf(x ≟ 5, A171)
G171 = CountIf(x ≟ 6, A171)
B171 = CountIf(x ≟ 1, A171)
H171: (B171 - 20)^(2) / 20 + (C171 - 20)^(2) / 20 + (D171 - 20)^(2) / 20 + (E171 - 20)^(2) / 20 + (F171 - 20)^(2) / 20 + (G171 - 20)^(2) / 20
I171 = Sum(abs(B171:G171 - 20))
J171: Max[B171:G171] - Min[B171:G171]
K171 = Max(abs(B171:G171 - 20))
L171: CountIf[x < 11, B171:G171] + CountIf[x > 29, B171:G171]
A172 = Sequence(Random[1, 6], k, 1, 120)
C172 = CountIf(x ≟ 2, A172)
D172 = CountIf(x ≟ 3, A172)
E172 = CountIf(x ≟ 4, A172)
F172 = CountIf(x ≟ 5, A172)
G172 = CountIf(x ≟ 6, A172)
B172 = CountIf(x ≟ 1, A172)
H172: (B172 - 20)^(2) / 20 + (C172 - 20)^(2) / 20 + (D172 - 20)^(2) / 20 + (E172 - 20)^(2) / 20 + (F172 - 20)^(2) / 20 + (G172 - 20)^(2) / 20
I172 = Sum(abs(B172:G172 - 20))
J172: Max[B172:G172] - Min[B172:G172]
K172 = Max(abs(B172:G172 - 20))
L172: CountIf[x < 11, B172:G172] + CountIf[x > 29, B172:G172]
A173 = Sequence(Random[1, 6], k, 1, 120)
C173 = CountIf(x ≟ 2, A173)
D173 = CountIf(x ≟ 3, A173)
E173 = CountIf(x ≟ 4, A173)
F173 = CountIf(x ≟ 5, A173)
G173 = CountIf(x ≟ 6, A173)
B173 = CountIf(x ≟ 1, A173)
H173: (B173 - 20)^(2) / 20 + (C173 - 20)^(2) / 20 + (D173 - 20)^(2) / 20 + (E173 - 20)^(2) / 20 + (F173 - 20)^(2) / 20 + (G173 - 20)^(2) / 20
I173 = Sum(abs(B173:G173 - 20))
J173: Max[B173:G173] - Min[B173:G173]
K173 = Max(abs(B173:G173 - 20))
L173: CountIf[x < 11, B173:G173] + CountIf[x > 29, B173:G173]
A174 = Sequence(Random[1, 6], k, 1, 120)
C174 = CountIf(x ≟ 2, A174)
D174 = CountIf(x ≟ 3, A174)
E174 = CountIf(x ≟ 4, A174)
F174 = CountIf(x ≟ 5, A174)
G174 = CountIf(x ≟ 6, A174)
B174 = CountIf(x ≟ 1, A174)
H174: (B174 - 20)^(2) / 20 + (C174 - 20)^(2) / 20 + (D174 - 20)^(2) / 20 + (E174 - 20)^(2) / 20 + (F174 - 20)^(2) / 20 + (G174 - 20)^(2) / 20
I174 = Sum(abs(B174:G174 - 20))
J174: Max[B174:G174] - Min[B174:G174]
K174 = Max(abs(B174:G174 - 20))
L174: CountIf[x < 11, B174:G174] + CountIf[x > 29, B174:G174]
A175 = Sequence(Random[1, 6], k, 1, 120)
C175 = CountIf(x ≟ 2, A175)
D175 = CountIf(x ≟ 3, A175)
E175 = CountIf(x ≟ 4, A175)
F175 = CountIf(x ≟ 5, A175)
G175 = CountIf(x ≟ 6, A175)
B175 = CountIf(x ≟ 1, A175)
H175: (B175 - 20)^(2) / 20 + (C175 - 20)^(2) / 20 + (D175 - 20)^(2) / 20 + (E175 - 20)^(2) / 20 + (F175 - 20)^(2) / 20 + (G175 - 20)^(2) / 20
I175 = Sum(abs(B175:G175 - 20))
J175: Max[B175:G175] - Min[B175:G175]
K175 = Max(abs(B175:G175 - 20))
L175: CountIf[x < 11, B175:G175] + CountIf[x > 29, B175:G175]
A176 = Sequence(Random[1, 6], k, 1, 120)
C176 = CountIf(x ≟ 2, A176)
D176 = CountIf(x ≟ 3, A176)
E176 = CountIf(x ≟ 4, A176)
F176 = CountIf(x ≟ 5, A176)
G176 = CountIf(x ≟ 6, A176)
B176 = CountIf(x ≟ 1, A176)
H176: (B176 - 20)^(2) / 20 + (C176 - 20)^(2) / 20 + (D176 - 20)^(2) / 20 + (E176 - 20)^(2) / 20 + (F176 - 20)^(2) / 20 + (G176 - 20)^(2) / 20
I176 = Sum(abs(B176:G176 - 20))
J176: Max[B176:G176] - Min[B176:G176]
K176 = Max(abs(B176:G176 - 20))
L176: CountIf[x < 11, B176:G176] + CountIf[x > 29, B176:G176]
A177 = Sequence(Random[1, 6], k, 1, 120)
C177 = CountIf(x ≟ 2, A177)
D177 = CountIf(x ≟ 3, A177)
E177 = CountIf(x ≟ 4, A177)
F177 = CountIf(x ≟ 5, A177)
G177 = CountIf(x ≟ 6, A177)
B177 = CountIf(x ≟ 1, A177)
H177: (B177 - 20)^(2) / 20 + (C177 - 20)^(2) / 20 + (D177 - 20)^(2) / 20 + (E177 - 20)^(2) / 20 + (F177 - 20)^(2) / 20 + (G177 - 20)^(2) / 20
I177 = Sum(abs(B177:G177 - 20))
J177: Max[B177:G177] - Min[B177:G177]
K177 = Max(abs(B177:G177 - 20))
L177: CountIf[x < 11, B177:G177] + CountIf[x > 29, B177:G177]
A178 = Sequence(Random[1, 6], k, 1, 120)
C178 = CountIf(x ≟ 2, A178)
D178 = CountIf(x ≟ 3, A178)
E178 = CountIf(x ≟ 4, A178)
F178 = CountIf(x ≟ 5, A178)
G178 = CountIf(x ≟ 6, A178)
B178 = CountIf(x ≟ 1, A178)
H178: (B178 - 20)^(2) / 20 + (C178 - 20)^(2) / 20 + (D178 - 20)^(2) / 20 + (E178 - 20)^(2) / 20 + (F178 - 20)^(2) / 20 + (G178 - 20)^(2) / 20
I178 = Sum(abs(B178:G178 - 20))
J178: Max[B178:G178] - Min[B178:G178]
K178 = Max(abs(B178:G178 - 20))
L178: CountIf[x < 11, B178:G178] + CountIf[x > 29, B178:G178]
A179 = Sequence(Random[1, 6], k, 1, 120)
C179 = CountIf(x ≟ 2, A179)
D179 = CountIf(x ≟ 3, A179)
E179 = CountIf(x ≟ 4, A179)
F179 = CountIf(x ≟ 5, A179)
G179 = CountIf(x ≟ 6, A179)
B179 = CountIf(x ≟ 1, A179)
H179: (B179 - 20)^(2) / 20 + (C179 - 20)^(2) / 20 + (D179 - 20)^(2) / 20 + (E179 - 20)^(2) / 20 + (F179 - 20)^(2) / 20 + (G179 - 20)^(2) / 20
I179 = Sum(abs(B179:G179 - 20))
J179: Max[B179:G179] - Min[B179:G179]
K179 = Max(abs(B179:G179 - 20))
L179: CountIf[x < 11, B179:G179] + CountIf[x > 29, B179:G179]
A180 = Sequence(Random[1, 6], k, 1, 120)
C180 = CountIf(x ≟ 2, A180)
D180 = CountIf(x ≟ 3, A180)
E180 = CountIf(x ≟ 4, A180)
F180 = CountIf(x ≟ 5, A180)
G180 = CountIf(x ≟ 6, A180)
B180 = CountIf(x ≟ 1, A180)
H180: (B180 - 20)^(2) / 20 + (C180 - 20)^(2) / 20 + (D180 - 20)^(2) / 20 + (E180 - 20)^(2) / 20 + (F180 - 20)^(2) / 20 + (G180 - 20)^(2) / 20
I180 = Sum(abs(B180:G180 - 20))
J180: Max[B180:G180] - Min[B180:G180]
K180 = Max(abs(B180:G180 - 20))
L180: CountIf[x < 11, B180:G180] + CountIf[x > 29, B180:G180]
A181 = Sequence(Random[1, 6], k, 1, 120)
C181 = CountIf(x ≟ 2, A181)
D181 = CountIf(x ≟ 3, A181)
E181 = CountIf(x ≟ 4, A181)
F181 = CountIf(x ≟ 5, A181)
G181 = CountIf(x ≟ 6, A181)
B181 = CountIf(x ≟ 1, A181)
H181: (B181 - 20)^(2) / 20 + (C181 - 20)^(2) / 20 + (D181 - 20)^(2) / 20 + (E181 - 20)^(2) / 20 + (F181 - 20)^(2) / 20 + (G181 - 20)^(2) / 20
I181 = Sum(abs(B181:G181 - 20))
J181: Max[B181:G181] - Min[B181:G181]
K181 = Max(abs(B181:G181 - 20))
L181: CountIf[x < 11, B181:G181] + CountIf[x > 29, B181:G181]
A182 = Sequence(Random[1, 6], k, 1, 120)
C182 = CountIf(x ≟ 2, A182)
D182 = CountIf(x ≟ 3, A182)
E182 = CountIf(x ≟ 4, A182)
F182 = CountIf(x ≟ 5, A182)
G182 = CountIf(x ≟ 6, A182)
B182 = CountIf(x ≟ 1, A182)
H182: (B182 - 20)^(2) / 20 + (C182 - 20)^(2) / 20 + (D182 - 20)^(2) / 20 + (E182 - 20)^(2) / 20 + (F182 - 20)^(2) / 20 + (G182 - 20)^(2) / 20
I182 = Sum(abs(B182:G182 - 20))
J182: Max[B182:G182] - Min[B182:G182]
K182 = Max(abs(B182:G182 - 20))
L182: CountIf[x < 11, B182:G182] + CountIf[x > 29, B182:G182]
A183 = Sequence(Random[1, 6], k, 1, 120)
C183 = CountIf(x ≟ 2, A183)
D183 = CountIf(x ≟ 3, A183)
E183 = CountIf(x ≟ 4, A183)
F183 = CountIf(x ≟ 5, A183)
G183 = CountIf(x ≟ 6, A183)
B183 = CountIf(x ≟ 1, A183)
H183: (B183 - 20)^(2) / 20 + (C183 - 20)^(2) / 20 + (D183 - 20)^(2) / 20 + (E183 - 20)^(2) / 20 + (F183 - 20)^(2) / 20 + (G183 - 20)^(2) / 20
I183 = Sum(abs(B183:G183 - 20))
J183: Max[B183:G183] - Min[B183:G183]
K183 = Max(abs(B183:G183 - 20))
L183: CountIf[x < 11, B183:G183] + CountIf[x > 29, B183:G183]
A184 = Sequence(Random[1, 6], k, 1, 120)
C184 = CountIf(x ≟ 2, A184)
D184 = CountIf(x ≟ 3, A184)
E184 = CountIf(x ≟ 4, A184)
F184 = CountIf(x ≟ 5, A184)
G184 = CountIf(x ≟ 6, A184)
B184 = CountIf(x ≟ 1, A184)
H184: (B184 - 20)^(2) / 20 + (C184 - 20)^(2) / 20 + (D184 - 20)^(2) / 20 + (E184 - 20)^(2) / 20 + (F184 - 20)^(2) / 20 + (G184 - 20)^(2) / 20
I184 = Sum(abs(B184:G184 - 20))
J184: Max[B184:G184] - Min[B184:G184]
K184 = Max(abs(B184:G184 - 20))
L184: CountIf[x < 11, B184:G184] + CountIf[x > 29, B184:G184]
A185 = Sequence(Random[1, 6], k, 1, 120)
C185 = CountIf(x ≟ 2, A185)
D185 = CountIf(x ≟ 3, A185)
E185 = CountIf(x ≟ 4, A185)
F185 = CountIf(x ≟ 5, A185)
G185 = CountIf(x ≟ 6, A185)
B185 = CountIf(x ≟ 1, A185)
H185: (B185 - 20)^(2) / 20 + (C185 - 20)^(2) / 20 + (D185 - 20)^(2) / 20 + (E185 - 20)^(2) / 20 + (F185 - 20)^(2) / 20 + (G185 - 20)^(2) / 20
I185 = Sum(abs(B185:G185 - 20))
J185: Max[B185:G185] - Min[B185:G185]
K185 = Max(abs(B185:G185 - 20))
L185: CountIf[x < 11, B185:G185] + CountIf[x > 29, B185:G185]
A186 = Sequence(Random[1, 6], k, 1, 120)
C186 = CountIf(x ≟ 2, A186)
D186 = CountIf(x ≟ 3, A186)
E186 = CountIf(x ≟ 4, A186)
F186 = CountIf(x ≟ 5, A186)
G186 = CountIf(x ≟ 6, A186)
B186 = CountIf(x ≟ 1, A186)
H186: (B186 - 20)^(2) / 20 + (C186 - 20)^(2) / 20 + (D186 - 20)^(2) / 20 + (E186 - 20)^(2) / 20 + (F186 - 20)^(2) / 20 + (G186 - 20)^(2) / 20
I186 = Sum(abs(B186:G186 - 20))
J186: Max[B186:G186] - Min[B186:G186]
K186 = Max(abs(B186:G186 - 20))
L186: CountIf[x < 11, B186:G186] + CountIf[x > 29, B186:G186]
A187 = Sequence(Random[1, 6], k, 1, 120)
C187 = CountIf(x ≟ 2, A187)
D187 = CountIf(x ≟ 3, A187)
E187 = CountIf(x ≟ 4, A187)
F187 = CountIf(x ≟ 5, A187)
G187 = CountIf(x ≟ 6, A187)
B187 = CountIf(x ≟ 1, A187)
H187: (B187 - 20)^(2) / 20 + (C187 - 20)^(2) / 20 + (D187 - 20)^(2) / 20 + (E187 - 20)^(2) / 20 + (F187 - 20)^(2) / 20 + (G187 - 20)^(2) / 20
I187 = Sum(abs(B187:G187 - 20))
J187: Max[B187:G187] - Min[B187:G187]
K187 = Max(abs(B187:G187 - 20))
L187: CountIf[x < 11, B187:G187] + CountIf[x > 29, B187:G187]
A188 = Sequence(Random[1, 6], k, 1, 120)
C188 = CountIf(x ≟ 2, A188)
D188 = CountIf(x ≟ 3, A188)
E188 = CountIf(x ≟ 4, A188)
F188 = CountIf(x ≟ 5, A188)
G188 = CountIf(x ≟ 6, A188)
B188 = CountIf(x ≟ 1, A188)
H188: (B188 - 20)^(2) / 20 + (C188 - 20)^(2) / 20 + (D188 - 20)^(2) / 20 + (E188 - 20)^(2) / 20 + (F188 - 20)^(2) / 20 + (G188 - 20)^(2) / 20
I188 = Sum(abs(B188:G188 - 20))
J188: Max[B188:G188] - Min[B188:G188]
K188 = Max(abs(B188:G188 - 20))
L188: CountIf[x < 11, B188:G188] + CountIf[x > 29, B188:G188]
A189 = Sequence(Random[1, 6], k, 1, 120)
C189 = CountIf(x ≟ 2, A189)
D189 = CountIf(x ≟ 3, A189)
E189 = CountIf(x ≟ 4, A189)
F189 = CountIf(x ≟ 5, A189)
G189 = CountIf(x ≟ 6, A189)
B189 = CountIf(x ≟ 1, A189)
H189: (B189 - 20)^(2) / 20 + (C189 - 20)^(2) / 20 + (D189 - 20)^(2) / 20 + (E189 - 20)^(2) / 20 + (F189 - 20)^(2) / 20 + (G189 - 20)^(2) / 20
I189 = Sum(abs(B189:G189 - 20))
J189: Max[B189:G189] - Min[B189:G189]
K189 = Max(abs(B189:G189 - 20))
L189: CountIf[x < 11, B189:G189] + CountIf[x > 29, B189:G189]
A190 = Sequence(Random[1, 6], k, 1, 120)
C190 = CountIf(x ≟ 2, A190)
D190 = CountIf(x ≟ 3, A190)
E190 = CountIf(x ≟ 4, A190)
F190 = CountIf(x ≟ 5, A190)
G190 = CountIf(x ≟ 6, A190)
B190 = CountIf(x ≟ 1, A190)
H190: (B190 - 20)^(2) / 20 + (C190 - 20)^(2) / 20 + (D190 - 20)^(2) / 20 + (E190 - 20)^(2) / 20 + (F190 - 20)^(2) / 20 + (G190 - 20)^(2) / 20
I190 = Sum(abs(B190:G190 - 20))
J190: Max[B190:G190] - Min[B190:G190]
K190 = Max(abs(B190:G190 - 20))
L190: CountIf[x < 11, B190:G190] + CountIf[x > 29, B190:G190]
A191 = Sequence(Random[1, 6], k, 1, 120)
C191 = CountIf(x ≟ 2, A191)
D191 = CountIf(x ≟ 3, A191)
E191 = CountIf(x ≟ 4, A191)
F191 = CountIf(x ≟ 5, A191)
G191 = CountIf(x ≟ 6, A191)
B191 = CountIf(x ≟ 1, A191)
H191: (B191 - 20)^(2) / 20 + (C191 - 20)^(2) / 20 + (D191 - 20)^(2) / 20 + (E191 - 20)^(2) / 20 + (F191 - 20)^(2) / 20 + (G191 - 20)^(2) / 20
I191 = Sum(abs(B191:G191 - 20))
J191: Max[B191:G191] - Min[B191:G191]
K191 = Max(abs(B191:G191 - 20))
L191: CountIf[x < 11, B191:G191] + CountIf[x > 29, B191:G191]
A192 = Sequence(Random[1, 6], k, 1, 120)
C192 = CountIf(x ≟ 2, A192)
D192 = CountIf(x ≟ 3, A192)
E192 = CountIf(x ≟ 4, A192)
F192 = CountIf(x ≟ 5, A192)
G192 = CountIf(x ≟ 6, A192)
B192 = CountIf(x ≟ 1, A192)
H192: (B192 - 20)^(2) / 20 + (C192 - 20)^(2) / 20 + (D192 - 20)^(2) / 20 + (E192 - 20)^(2) / 20 + (F192 - 20)^(2) / 20 + (G192 - 20)^(2) / 20
I192 = Sum(abs(B192:G192 - 20))
J192: Max[B192:G192] - Min[B192:G192]
K192 = Max(abs(B192:G192 - 20))
L192: CountIf[x < 11, B192:G192] + CountIf[x > 29, B192:G192]
A193 = Sequence(Random[1, 6], k, 1, 120)
C193 = CountIf(x ≟ 2, A193)
D193 = CountIf(x ≟ 3, A193)
E193 = CountIf(x ≟ 4, A193)
F193 = CountIf(x ≟ 5, A193)
G193 = CountIf(x ≟ 6, A193)
B193 = CountIf(x ≟ 1, A193)
H193: (B193 - 20)^(2) / 20 + (C193 - 20)^(2) / 20 + (D193 - 20)^(2) / 20 + (E193 - 20)^(2) / 20 + (F193 - 20)^(2) / 20 + (G193 - 20)^(2) / 20
I193 = Sum(abs(B193:G193 - 20))
J193: Max[B193:G193] - Min[B193:G193]
K193 = Max(abs(B193:G193 - 20))
L193: CountIf[x < 11, B193:G193] + CountIf[x > 29, B193:G193]
A194 = Sequence(Random[1, 6], k, 1, 120)
C194 = CountIf(x ≟ 2, A194)
D194 = CountIf(x ≟ 3, A194)
E194 = CountIf(x ≟ 4, A194)
F194 = CountIf(x ≟ 5, A194)
G194 = CountIf(x ≟ 6, A194)
B194 = CountIf(x ≟ 1, A194)
H194: (B194 - 20)^(2) / 20 + (C194 - 20)^(2) / 20 + (D194 - 20)^(2) / 20 + (E194 - 20)^(2) / 20 + (F194 - 20)^(2) / 20 + (G194 - 20)^(2) / 20
I194 = Sum(abs(B194:G194 - 20))
J194: Max[B194:G194] - Min[B194:G194]
K194 = Max(abs(B194:G194 - 20))
L194: CountIf[x < 11, B194:G194] + CountIf[x > 29, B194:G194]
A195 = Sequence(Random[1, 6], k, 1, 120)
C195 = CountIf(x ≟ 2, A195)
D195 = CountIf(x ≟ 3, A195)
E195 = CountIf(x ≟ 4, A195)
F195 = CountIf(x ≟ 5, A195)
G195 = CountIf(x ≟ 6, A195)
B195 = CountIf(x ≟ 1, A195)
H195: (B195 - 20)^(2) / 20 + (C195 - 20)^(2) / 20 + (D195 - 20)^(2) / 20 + (E195 - 20)^(2) / 20 + (F195 - 20)^(2) / 20 + (G195 - 20)^(2) / 20
I195 = Sum(abs(B195:G195 - 20))
J195: Max[B195:G195] - Min[B195:G195]
K195 = Max(abs(B195:G195 - 20))
L195: CountIf[x < 11, B195:G195] + CountIf[x > 29, B195:G195]
A196 = Sequence(Random[1, 6], k, 1, 120)
C196 = CountIf(x ≟ 2, A196)
D196 = CountIf(x ≟ 3, A196)
E196 = CountIf(x ≟ 4, A196)
F196 = CountIf(x ≟ 5, A196)
G196 = CountIf(x ≟ 6, A196)
B196 = CountIf(x ≟ 1, A196)
H196: (B196 - 20)^(2) / 20 + (C196 - 20)^(2) / 20 + (D196 - 20)^(2) / 20 + (E196 - 20)^(2) / 20 + (F196 - 20)^(2) / 20 + (G196 - 20)^(2) / 20
I196 = Sum(abs(B196:G196 - 20))
J196: Max[B196:G196] - Min[B196:G196]
K196 = Max(abs(B196:G196 - 20))
L196: CountIf[x < 11, B196:G196] + CountIf[x > 29, B196:G196]
A197 = Sequence(Random[1, 6], k, 1, 120)
C197 = CountIf(x ≟ 2, A197)
D197 = CountIf(x ≟ 3, A197)
E197 = CountIf(x ≟ 4, A197)
F197 = CountIf(x ≟ 5, A197)
G197 = CountIf(x ≟ 6, A197)
B197 = CountIf(x ≟ 1, A197)
H197: (B197 - 20)^(2) / 20 + (C197 - 20)^(2) / 20 + (D197 - 20)^(2) / 20 + (E197 - 20)^(2) / 20 + (F197 - 20)^(2) / 20 + (G197 - 20)^(2) / 20
I197 = Sum(abs(B197:G197 - 20))
J197: Max[B197:G197] - Min[B197:G197]
K197 = Max(abs(B197:G197 - 20))
L197: CountIf[x < 11, B197:G197] + CountIf[x > 29, B197:G197]
A198 = Sequence(Random[1, 6], k, 1, 120)
C198 = CountIf(x ≟ 2, A198)
D198 = CountIf(x ≟ 3, A198)
E198 = CountIf(x ≟ 4, A198)
F198 = CountIf(x ≟ 5, A198)
G198 = CountIf(x ≟ 6, A198)
B198 = CountIf(x ≟ 1, A198)
H198: (B198 - 20)^(2) / 20 + (C198 - 20)^(2) / 20 + (D198 - 20)^(2) / 20 + (E198 - 20)^(2) / 20 + (F198 - 20)^(2) / 20 + (G198 - 20)^(2) / 20
I198 = Sum(abs(B198:G198 - 20))
J198: Max[B198:G198] - Min[B198:G198]
K198 = Max(abs(B198:G198 - 20))
L198: CountIf[x < 11, B198:G198] + CountIf[x > 29, B198:G198]
A199 = Sequence(Random[1, 6], k, 1, 120)
C199 = CountIf(x ≟ 2, A199)
D199 = CountIf(x ≟ 3, A199)
E199 = CountIf(x ≟ 4, A199)
F199 = CountIf(x ≟ 5, A199)
G199 = CountIf(x ≟ 6, A199)
B199 = CountIf(x ≟ 1, A199)
H199: (B199 - 20)^(2) / 20 + (C199 - 20)^(2) / 20 + (D199 - 20)^(2) / 20 + (E199 - 20)^(2) / 20 + (F199 - 20)^(2) / 20 + (G199 - 20)^(2) / 20
I199 = Sum(abs(B199:G199 - 20))
J199: Max[B199:G199] - Min[B199:G199]
K199 = Max(abs(B199:G199 - 20))
L199: CountIf[x < 11, B199:G199] + CountIf[x > 29, B199:G199]
A200 = Sequence(Random[1, 6], k, 1, 120)
C200 = CountIf(x ≟ 2, A200)
D200 = CountIf(x ≟ 3, A200)
E200 = CountIf(x ≟ 4, A200)
F200 = CountIf(x ≟ 5, A200)
G200 = CountIf(x ≟ 6, A200)
B200 = CountIf(x ≟ 1, A200)
H200: (B200 - 20)^(2) / 20 + (C200 - 20)^(2) / 20 + (D200 - 20)^(2) / 20 + (E200 - 20)^(2) / 20 + (F200 - 20)^(2) / 20 + (G200 - 20)^(2) / 20
I200 = Sum(abs(B200:G200 - 20))
J200: Max[B200:G200] - Min[B200:G200]
K200 = Max(abs(B200:G200 - 20))
L200: CountIf[x < 11, B200:G200] + CountIf[x > 29, B200:G200]
A201 = Sequence(Random[1, 6], k, 1, 120)
C201 = CountIf(x ≟ 2, A201)
D201 = CountIf(x ≟ 3, A201)
E201 = CountIf(x ≟ 4, A201)
F201 = CountIf(x ≟ 5, A201)
G201 = CountIf(x ≟ 6, A201)
B201 = CountIf(x ≟ 1, A201)
H201: (B201 - 20)^(2) / 20 + (C201 - 20)^(2) / 20 + (D201 - 20)^(2) / 20 + (E201 - 20)^(2) / 20 + (F201 - 20)^(2) / 20 + (G201 - 20)^(2) / 20
I201 = Sum(abs(B201:G201 - 20))
J201: Max[B201:G201] - Min[B201:G201]
K201 = Max(abs(B201:G201 - 20))
L201: CountIf[x < 11, B201:G201] + CountIf[x > 29, B201:G201]
A202 = Sequence(Random[1, 6], k, 1, 120)
C202 = CountIf(x ≟ 2, A202)
D202 = CountIf(x ≟ 3, A202)
E202 = CountIf(x ≟ 4, A202)
F202 = CountIf(x ≟ 5, A202)
G202 = CountIf(x ≟ 6, A202)
B202 = CountIf(x ≟ 1, A202)
H202: (B202 - 20)^(2) / 20 + (C202 - 20)^(2) / 20 + (D202 - 20)^(2) / 20 + (E202 - 20)^(2) / 20 + (F202 - 20)^(2) / 20 + (G202 - 20)^(2) / 20
I202 = Sum(abs(B202:G202 - 20))
J202: Max[B202:G202] - Min[B202:G202]
K202 = Max(abs(B202:G202 - 20))
L202: CountIf[x < 11, B202:G202] + CountIf[x > 29, B202:G202]
A203 = Sequence(Random[1, 6], k, 1, 120)
C203 = CountIf(x ≟ 2, A203)
D203 = CountIf(x ≟ 3, A203)
E203 = CountIf(x ≟ 4, A203)
F203 = CountIf(x ≟ 5, A203)
G203 = CountIf(x ≟ 6, A203)
B203 = CountIf(x ≟ 1, A203)
H203: (B203 - 20)^(2) / 20 + (C203 - 20)^(2) / 20 + (D203 - 20)^(2) / 20 + (E203 - 20)^(2) / 20 + (F203 - 20)^(2) / 20 + (G203 - 20)^(2) / 20
I203 = Sum(abs(B203:G203 - 20))
J203: Max[B203:G203] - Min[B203:G203]
K203 = Max(abs(B203:G203 - 20))
L203: CountIf[x < 11, B203:G203] + CountIf[x > 29, B203:G203]
A204 = Sequence(Random[1, 6], k, 1, 120)
C204 = CountIf(x ≟ 2, A204)
D204 = CountIf(x ≟ 3, A204)
E204 = CountIf(x ≟ 4, A204)
F204 = CountIf(x ≟ 5, A204)
G204 = CountIf(x ≟ 6, A204)
B204 = CountIf(x ≟ 1, A204)
H204: (B204 - 20)^(2) / 20 + (C204 - 20)^(2) / 20 + (D204 - 20)^(2) / 20 + (E204 - 20)^(2) / 20 + (F204 - 20)^(2) / 20 + (G204 - 20)^(2) / 20
I204 = Sum(abs(B204:G204 - 20))
J204: Max[B204:G204] - Min[B204:G204]
K204 = Max(abs(B204:G204 - 20))
L204: CountIf[x < 11, B204:G204] + CountIf[x > 29, B204:G204]
A205 = Sequence(Random[1, 6], k, 1, 120)
C205 = CountIf(x ≟ 2, A205)
D205 = CountIf(x ≟ 3, A205)
E205 = CountIf(x ≟ 4, A205)
F205 = CountIf(x ≟ 5, A205)
G205 = CountIf(x ≟ 6, A205)
B205 = CountIf(x ≟ 1, A205)
H205: (B205 - 20)^(2) / 20 + (C205 - 20)^(2) / 20 + (D205 - 20)^(2) / 20 + (E205 - 20)^(2) / 20 + (F205 - 20)^(2) / 20 + (G205 - 20)^(2) / 20
I205 = Sum(abs(B205:G205 - 20))
J205: Max[B205:G205] - Min[B205:G205]
K205 = Max(abs(B205:G205 - 20))
L205: CountIf[x < 11, B205:G205] + CountIf[x > 29, B205:G205]
A206 = Sequence(Random[1, 6], k, 1, 120)
C206 = CountIf(x ≟ 2, A206)
D206 = CountIf(x ≟ 3, A206)
E206 = CountIf(x ≟ 4, A206)
F206 = CountIf(x ≟ 5, A206)
G206 = CountIf(x ≟ 6, A206)
B206 = CountIf(x ≟ 1, A206)
H206: (B206 - 20)^(2) / 20 + (C206 - 20)^(2) / 20 + (D206 - 20)^(2) / 20 + (E206 - 20)^(2) / 20 + (F206 - 20)^(2) / 20 + (G206 - 20)^(2) / 20
I206 = Sum(abs(B206:G206 - 20))
J206: Max[B206:G206] - Min[B206:G206]
K206 = Max(abs(B206:G206 - 20))
L206: CountIf[x < 11, B206:G206] + CountIf[x > 29, B206:G206]
A207 = Sequence(Random[1, 6], k, 1, 120)
C207 = CountIf(x ≟ 2, A207)
D207 = CountIf(x ≟ 3, A207)
E207 = CountIf(x ≟ 4, A207)
F207 = CountIf(x ≟ 5, A207)
G207 = CountIf(x ≟ 6, A207)
B207 = CountIf(x ≟ 1, A207)
H207: (B207 - 20)^(2) / 20 + (C207 - 20)^(2) / 20 + (D207 - 20)^(2) / 20 + (E207 - 20)^(2) / 20 + (F207 - 20)^(2) / 20 + (G207 - 20)^(2) / 20
I207 = Sum(abs(B207:G207 - 20))
J207: Max[B207:G207] - Min[B207:G207]
K207 = Max(abs(B207:G207 - 20))
L207: CountIf[x < 11, B207:G207] + CountIf[x > 29, B207:G207]
A208 = Sequence(Random[1, 6], k, 1, 120)
C208 = CountIf(x ≟ 2, A208)
D208 = CountIf(x ≟ 3, A208)
E208 = CountIf(x ≟ 4, A208)
F208 = CountIf(x ≟ 5, A208)
G208 = CountIf(x ≟ 6, A208)
B208 = CountIf(x ≟ 1, A208)
H208: (B208 - 20)^(2) / 20 + (C208 - 20)^(2) / 20 + (D208 - 20)^(2) / 20 + (E208 - 20)^(2) / 20 + (F208 - 20)^(2) / 20 + (G208 - 20)^(2) / 20
I208 = Sum(abs(B208:G208 - 20))
J208: Max[B208:G208] - Min[B208:G208]
K208 = Max(abs(B208:G208 - 20))
L208: CountIf[x < 11, B208:G208] + CountIf[x > 29, B208:G208]
A209 = Sequence(Random[1, 6], k, 1, 120)
C209 = CountIf(x ≟ 2, A209)
D209 = CountIf(x ≟ 3, A209)
E209 = CountIf(x ≟ 4, A209)
F209 = CountIf(x ≟ 5, A209)
G209 = CountIf(x ≟ 6, A209)
B209 = CountIf(x ≟ 1, A209)
H209: (B209 - 20)^(2) / 20 + (C209 - 20)^(2) / 20 + (D209 - 20)^(2) / 20 + (E209 - 20)^(2) / 20 + (F209 - 20)^(2) / 20 + (G209 - 20)^(2) / 20
I209 = Sum(abs(B209:G209 - 20))
J209: Max[B209:G209] - Min[B209:G209]
K209 = Max(abs(B209:G209 - 20))
L209: CountIf[x < 11, B209:G209] + CountIf[x > 29, B209:G209]
A210 = Sequence(Random[1, 6], k, 1, 120)
C210 = CountIf(x ≟ 2, A210)
D210 = CountIf(x ≟ 3, A210)
E210 = CountIf(x ≟ 4, A210)
F210 = CountIf(x ≟ 5, A210)
G210 = CountIf(x ≟ 6, A210)
B210 = CountIf(x ≟ 1, A210)
H210: (B210 - 20)^(2) / 20 + (C210 - 20)^(2) / 20 + (D210 - 20)^(2) / 20 + (E210 - 20)^(2) / 20 + (F210 - 20)^(2) / 20 + (G210 - 20)^(2) / 20
I210 = Sum(abs(B210:G210 - 20))
J210: Max[B210:G210] - Min[B210:G210]
K210 = Max(abs(B210:G210 - 20))
L210: CountIf[x < 11, B210:G210] + CountIf[x > 29, B210:G210]
A211 = Sequence(Random[1, 6], k, 1, 120)
C211 = CountIf(x ≟ 2, A211)
D211 = CountIf(x ≟ 3, A211)
E211 = CountIf(x ≟ 4, A211)
F211 = CountIf(x ≟ 5, A211)
G211 = CountIf(x ≟ 6, A211)
B211 = CountIf(x ≟ 1, A211)
H211: (B211 - 20)^(2) / 20 + (C211 - 20)^(2) / 20 + (D211 - 20)^(2) / 20 + (E211 - 20)^(2) / 20 + (F211 - 20)^(2) / 20 + (G211 - 20)^(2) / 20
I211 = Sum(abs(B211:G211 - 20))
J211: Max[B211:G211] - Min[B211:G211]
K211 = Max(abs(B211:G211 - 20))
L211: CountIf[x < 11, B211:G211] + CountIf[x > 29, B211:G211]
A212 = Sequence(Random[1, 6], k, 1, 120)
C212 = CountIf(x ≟ 2, A212)
D212 = CountIf(x ≟ 3, A212)
E212 = CountIf(x ≟ 4, A212)
F212 = CountIf(x ≟ 5, A212)
G212 = CountIf(x ≟ 6, A212)
B212 = CountIf(x ≟ 1, A212)
H212: (B212 - 20)^(2) / 20 + (C212 - 20)^(2) / 20 + (D212 - 20)^(2) / 20 + (E212 - 20)^(2) / 20 + (F212 - 20)^(2) / 20 + (G212 - 20)^(2) / 20
I212 = Sum(abs(B212:G212 - 20))
J212: Max[B212:G212] - Min[B212:G212]
K212 = Max(abs(B212:G212 - 20))
L212: CountIf[x < 11, B212:G212] + CountIf[x > 29, B212:G212]
A213 = Sequence(Random[1, 6], k, 1, 120)
C213 = CountIf(x ≟ 2, A213)
D213 = CountIf(x ≟ 3, A213)
E213 = CountIf(x ≟ 4, A213)
F213 = CountIf(x ≟ 5, A213)
G213 = CountIf(x ≟ 6, A213)
B213 = CountIf(x ≟ 1, A213)
H213: (B213 - 20)^(2) / 20 + (C213 - 20)^(2) / 20 + (D213 - 20)^(2) / 20 + (E213 - 20)^(2) / 20 + (F213 - 20)^(2) / 20 + (G213 - 20)^(2) / 20
I213 = Sum(abs(B213:G213 - 20))
J213: Max[B213:G213] - Min[B213:G213]
K213 = Max(abs(B213:G213 - 20))
L213: CountIf[x < 11, B213:G213] + CountIf[x > 29, B213:G213]
A214 = Sequence(Random[1, 6], k, 1, 120)
C214 = CountIf(x ≟ 2, A214)
D214 = CountIf(x ≟ 3, A214)
E214 = CountIf(x ≟ 4, A214)
F214 = CountIf(x ≟ 5, A214)
G214 = CountIf(x ≟ 6, A214)
B214 = CountIf(x ≟ 1, A214)
H214: (B214 - 20)^(2) / 20 + (C214 - 20)^(2) / 20 + (D214 - 20)^(2) / 20 + (E214 - 20)^(2) / 20 + (F214 - 20)^(2) / 20 + (G214 - 20)^(2) / 20
I214 = Sum(abs(B214:G214 - 20))
J214: Max[B214:G214] - Min[B214:G214]
K214 = Max(abs(B214:G214 - 20))
L214: CountIf[x < 11, B214:G214] + CountIf[x > 29, B214:G214]
A215 = Sequence(Random[1, 6], k, 1, 120)
C215 = CountIf(x ≟ 2, A215)
D215 = CountIf(x ≟ 3, A215)
E215 = CountIf(x ≟ 4, A215)
F215 = CountIf(x ≟ 5, A215)
G215 = CountIf(x ≟ 6, A215)
B215 = CountIf(x ≟ 1, A215)
H215: (B215 - 20)^(2) / 20 + (C215 - 20)^(2) / 20 + (D215 - 20)^(2) / 20 + (E215 - 20)^(2) / 20 + (F215 - 20)^(2) / 20 + (G215 - 20)^(2) / 20
I215 = Sum(abs(B215:G215 - 20))
J215: Max[B215:G215] - Min[B215:G215]
K215 = Max(abs(B215:G215 - 20))
L215: CountIf[x < 11, B215:G215] + CountIf[x > 29, B215:G215]
A216 = Sequence(Random[1, 6], k, 1, 120)
C216 = CountIf(x ≟ 2, A216)
D216 = CountIf(x ≟ 3, A216)
E216 = CountIf(x ≟ 4, A216)
F216 = CountIf(x ≟ 5, A216)
G216 = CountIf(x ≟ 6, A216)
B216 = CountIf(x ≟ 1, A216)
H216: (B216 - 20)^(2) / 20 + (C216 - 20)^(2) / 20 + (D216 - 20)^(2) / 20 + (E216 - 20)^(2) / 20 + (F216 - 20)^(2) / 20 + (G216 - 20)^(2) / 20
I216 = Sum(abs(B216:G216 - 20))
J216: Max[B216:G216] - Min[B216:G216]
K216 = Max(abs(B216:G216 - 20))
L216: CountIf[x < 11, B216:G216] + CountIf[x > 29, B216:G216]
A217 = Sequence(Random[1, 6], k, 1, 120)
C217 = CountIf(x ≟ 2, A217)
D217 = CountIf(x ≟ 3, A217)
E217 = CountIf(x ≟ 4, A217)
F217 = CountIf(x ≟ 5, A217)
G217 = CountIf(x ≟ 6, A217)
B217 = CountIf(x ≟ 1, A217)
H217: (B217 - 20)^(2) / 20 + (C217 - 20)^(2) / 20 + (D217 - 20)^(2) / 20 + (E217 - 20)^(2) / 20 + (F217 - 20)^(2) / 20 + (G217 - 20)^(2) / 20
I217 = Sum(abs(B217:G217 - 20))
J217: Max[B217:G217] - Min[B217:G217]
K217 = Max(abs(B217:G217 - 20))
L217: CountIf[x < 11, B217:G217] + CountIf[x > 29, B217:G217]
A218 = Sequence(Random[1, 6], k, 1, 120)
C218 = CountIf(x ≟ 2, A218)
D218 = CountIf(x ≟ 3, A218)
E218 = CountIf(x ≟ 4, A218)
F218 = CountIf(x ≟ 5, A218)
G218 = CountIf(x ≟ 6, A218)
B218 = CountIf(x ≟ 1, A218)
H218: (B218 - 20)^(2) / 20 + (C218 - 20)^(2) / 20 + (D218 - 20)^(2) / 20 + (E218 - 20)^(2) / 20 + (F218 - 20)^(2) / 20 + (G218 - 20)^(2) / 20
I218 = Sum(abs(B218:G218 - 20))
J218: Max[B218:G218] - Min[B218:G218]
K218 = Max(abs(B218:G218 - 20))
L218: CountIf[x < 11, B218:G218] + CountIf[x > 29, B218:G218]
A219 = Sequence(Random[1, 6], k, 1, 120)
C219 = CountIf(x ≟ 2, A219)
D219 = CountIf(x ≟ 3, A219)
E219 = CountIf(x ≟ 4, A219)
F219 = CountIf(x ≟ 5, A219)
G219 = CountIf(x ≟ 6, A219)
B219 = CountIf(x ≟ 1, A219)
H219: (B219 - 20)^(2) / 20 + (C219 - 20)^(2) / 20 + (D219 - 20)^(2) / 20 + (E219 - 20)^(2) / 20 + (F219 - 20)^(2) / 20 + (G219 - 20)^(2) / 20
I219 = Sum(abs(B219:G219 - 20))
J219: Max[B219:G219] - Min[B219:G219]
K219 = Max(abs(B219:G219 - 20))
L219: CountIf[x < 11, B219:G219] + CountIf[x > 29, B219:G219]
A220 = Sequence(Random[1, 6], k, 1, 120)
C220 = CountIf(x ≟ 2, A220)
D220 = CountIf(x ≟ 3, A220)
E220 = CountIf(x ≟ 4, A220)
F220 = CountIf(x ≟ 5, A220)
G220 = CountIf(x ≟ 6, A220)
B220 = CountIf(x ≟ 1, A220)
H220: (B220 - 20)^(2) / 20 + (C220 - 20)^(2) / 20 + (D220 - 20)^(2) / 20 + (E220 - 20)^(2) / 20 + (F220 - 20)^(2) / 20 + (G220 - 20)^(2) / 20
I220 = Sum(abs(B220:G220 - 20))
J220: Max[B220:G220] - Min[B220:G220]
K220 = Max(abs(B220:G220 - 20))
L220: CountIf[x < 11, B220:G220] + CountIf[x > 29, B220:G220]
A221 = Sequence(Random[1, 6], k, 1, 120)
C221 = CountIf(x ≟ 2, A221)
D221 = CountIf(x ≟ 3, A221)
E221 = CountIf(x ≟ 4, A221)
F221 = CountIf(x ≟ 5, A221)
G221 = CountIf(x ≟ 6, A221)
B221 = CountIf(x ≟ 1, A221)
H221: (B221 - 20)^(2) / 20 + (C221 - 20)^(2) / 20 + (D221 - 20)^(2) / 20 + (E221 - 20)^(2) / 20 + (F221 - 20)^(2) / 20 + (G221 - 20)^(2) / 20
I221 = Sum(abs(B221:G221 - 20))
J221: Max[B221:G221] - Min[B221:G221]
K221 = Max(abs(B221:G221 - 20))
L221: CountIf[x < 11, B221:G221] + CountIf[x > 29, B221:G221]
A222 = Sequence(Random[1, 6], k, 1, 120)
C222 = CountIf(x ≟ 2, A222)
D222 = CountIf(x ≟ 3, A222)
E222 = CountIf(x ≟ 4, A222)
F222 = CountIf(x ≟ 5, A222)
G222 = CountIf(x ≟ 6, A222)
B222 = CountIf(x ≟ 1, A222)
H222: (B222 - 20)^(2) / 20 + (C222 - 20)^(2) / 20 + (D222 - 20)^(2) / 20 + (E222 - 20)^(2) / 20 + (F222 - 20)^(2) / 20 + (G222 - 20)^(2) / 20
I222 = Sum(abs(B222:G222 - 20))
J222: Max[B222:G222] - Min[B222:G222]
K222 = Max(abs(B222:G222 - 20))
L222: CountIf[x < 11, B222:G222] + CountIf[x > 29, B222:G222]
A223 = Sequence(Random[1, 6], k, 1, 120)
C223 = CountIf(x ≟ 2, A223)
D223 = CountIf(x ≟ 3, A223)
E223 = CountIf(x ≟ 4, A223)
F223 = CountIf(x ≟ 5, A223)
G223 = CountIf(x ≟ 6, A223)
B223 = CountIf(x ≟ 1, A223)
H223: (B223 - 20)^(2) / 20 + (C223 - 20)^(2) / 20 + (D223 - 20)^(2) / 20 + (E223 - 20)^(2) / 20 + (F223 - 20)^(2) / 20 + (G223 - 20)^(2) / 20
I223 = Sum(abs(B223:G223 - 20))
J223: Max[B223:G223] - Min[B223:G223]
K223 = Max(abs(B223:G223 - 20))
L223: CountIf[x < 11, B223:G223] + CountIf[x > 29, B223:G223]
A224 = Sequence(Random[1, 6], k, 1, 120)
C224 = CountIf(x ≟ 2, A224)
D224 = CountIf(x ≟ 3, A224)
E224 = CountIf(x ≟ 4, A224)
F224 = CountIf(x ≟ 5, A224)
G224 = CountIf(x ≟ 6, A224)
B224 = CountIf(x ≟ 1, A224)
H224: (B224 - 20)^(2) / 20 + (C224 - 20)^(2) / 20 + (D224 - 20)^(2) / 20 + (E224 - 20)^(2) / 20 + (F224 - 20)^(2) / 20 + (G224 - 20)^(2) / 20
I224 = Sum(abs(B224:G224 - 20))
J224: Max[B224:G224] - Min[B224:G224]
K224 = Max(abs(B224:G224 - 20))
L224: CountIf[x < 11, B224:G224] + CountIf[x > 29, B224:G224]
A225 = Sequence(Random[1, 6], k, 1, 120)
C225 = CountIf(x ≟ 2, A225)
D225 = CountIf(x ≟ 3, A225)
E225 = CountIf(x ≟ 4, A225)
F225 = CountIf(x ≟ 5, A225)
G225 = CountIf(x ≟ 6, A225)
B225 = CountIf(x ≟ 1, A225)
H225: (B225 - 20)^(2) / 20 + (C225 - 20)^(2) / 20 + (D225 - 20)^(2) / 20 + (E225 - 20)^(2) / 20 + (F225 - 20)^(2) / 20 + (G225 - 20)^(2) / 20
I225 = Sum(abs(B225:G225 - 20))
J225: Max[B225:G225] - Min[B225:G225]
K225 = Max(abs(B225:G225 - 20))
L225: CountIf[x < 11, B225:G225] + CountIf[x > 29, B225:G225]
A226 = Sequence(Random[1, 6], k, 1, 120)
C226 = CountIf(x ≟ 2, A226)
D226 = CountIf(x ≟ 3, A226)
E226 = CountIf(x ≟ 4, A226)
F226 = CountIf(x ≟ 5, A226)
G226 = CountIf(x ≟ 6, A226)
B226 = CountIf(x ≟ 1, A226)
H226: (B226 - 20)^(2) / 20 + (C226 - 20)^(2) / 20 + (D226 - 20)^(2) / 20 + (E226 - 20)^(2) / 20 + (F226 - 20)^(2) / 20 + (G226 - 20)^(2) / 20
I226 = Sum(abs(B226:G226 - 20))
J226: Max[B226:G226] - Min[B226:G226]
K226 = Max(abs(B226:G226 - 20))
L226: CountIf[x < 11, B226:G226] + CountIf[x > 29, B226:G226]
A227 = Sequence(Random[1, 6], k, 1, 120)
C227 = CountIf(x ≟ 2, A227)
D227 = CountIf(x ≟ 3, A227)
E227 = CountIf(x ≟ 4, A227)
F227 = CountIf(x ≟ 5, A227)
G227 = CountIf(x ≟ 6, A227)
B227 = CountIf(x ≟ 1, A227)
H227: (B227 - 20)^(2) / 20 + (C227 - 20)^(2) / 20 + (D227 - 20)^(2) / 20 + (E227 - 20)^(2) / 20 + (F227 - 20)^(2) / 20 + (G227 - 20)^(2) / 20
I227 = Sum(abs(B227:G227 - 20))
J227: Max[B227:G227] - Min[B227:G227]
K227 = Max(abs(B227:G227 - 20))
L227: CountIf[x < 11, B227:G227] + CountIf[x > 29, B227:G227]
A228 = Sequence(Random[1, 6], k, 1, 120)
C228 = CountIf(x ≟ 2, A228)
D228 = CountIf(x ≟ 3, A228)
E228 = CountIf(x ≟ 4, A228)
F228 = CountIf(x ≟ 5, A228)
G228 = CountIf(x ≟ 6, A228)
B228 = CountIf(x ≟ 1, A228)
H228: (B228 - 20)^(2) / 20 + (C228 - 20)^(2) / 20 + (D228 - 20)^(2) / 20 + (E228 - 20)^(2) / 20 + (F228 - 20)^(2) / 20 + (G228 - 20)^(2) / 20
I228 = Sum(abs(B228:G228 - 20))
J228: Max[B228:G228] - Min[B228:G228]
K228 = Max(abs(B228:G228 - 20))
L228: CountIf[x < 11, B228:G228] + CountIf[x > 29, B228:G228]
A229 = Sequence(Random[1, 6], k, 1, 120)
C229 = CountIf(x ≟ 2, A229)
D229 = CountIf(x ≟ 3, A229)
E229 = CountIf(x ≟ 4, A229)
F229 = CountIf(x ≟ 5, A229)
G229 = CountIf(x ≟ 6, A229)
B229 = CountIf(x ≟ 1, A229)
H229: (B229 - 20)^(2) / 20 + (C229 - 20)^(2) / 20 + (D229 - 20)^(2) / 20 + (E229 - 20)^(2) / 20 + (F229 - 20)^(2) / 20 + (G229 - 20)^(2) / 20
I229 = Sum(abs(B229:G229 - 20))
J229: Max[B229:G229] - Min[B229:G229]
K229 = Max(abs(B229:G229 - 20))
L229: CountIf[x < 11, B229:G229] + CountIf[x > 29, B229:G229]
A230 = Sequence(Random[1, 6], k, 1, 120)
C230 = CountIf(x ≟ 2, A230)
D230 = CountIf(x ≟ 3, A230)
E230 = CountIf(x ≟ 4, A230)
F230 = CountIf(x ≟ 5, A230)
G230 = CountIf(x ≟ 6, A230)
B230 = CountIf(x ≟ 1, A230)
H230: (B230 - 20)^(2) / 20 + (C230 - 20)^(2) / 20 + (D230 - 20)^(2) / 20 + (E230 - 20)^(2) / 20 + (F230 - 20)^(2) / 20 + (G230 - 20)^(2) / 20
I230 = Sum(abs(B230:G230 - 20))
J230: Max[B230:G230] - Min[B230:G230]
K230 = Max(abs(B230:G230 - 20))
L230: CountIf[x < 11, B230:G230] + CountIf[x > 29, B230:G230]
A231 = Sequence(Random[1, 6], k, 1, 120)
C231 = CountIf(x ≟ 2, A231)
D231 = CountIf(x ≟ 3, A231)
E231 = CountIf(x ≟ 4, A231)
F231 = CountIf(x ≟ 5, A231)
G231 = CountIf(x ≟ 6, A231)
B231 = CountIf(x ≟ 1, A231)
H231: (B231 - 20)^(2) / 20 + (C231 - 20)^(2) / 20 + (D231 - 20)^(2) / 20 + (E231 - 20)^(2) / 20 + (F231 - 20)^(2) / 20 + (G231 - 20)^(2) / 20
I231 = Sum(abs(B231:G231 - 20))
J231: Max[B231:G231] - Min[B231:G231]
K231 = Max(abs(B231:G231 - 20))
L231: CountIf[x < 11, B231:G231] + CountIf[x > 29, B231:G231]
A232 = Sequence(Random[1, 6], k, 1, 120)
C232 = CountIf(x ≟ 2, A232)
D232 = CountIf(x ≟ 3, A232)
E232 = CountIf(x ≟ 4, A232)
F232 = CountIf(x ≟ 5, A232)
G232 = CountIf(x ≟ 6, A232)
B232 = CountIf(x ≟ 1, A232)
H232: (B232 - 20)^(2) / 20 + (C232 - 20)^(2) / 20 + (D232 - 20)^(2) / 20 + (E232 - 20)^(2) / 20 + (F232 - 20)^(2) / 20 + (G232 - 20)^(2) / 20
I232 = Sum(abs(B232:G232 - 20))
J232: Max[B232:G232] - Min[B232:G232]
K232 = Max(abs(B232:G232 - 20))
L232: CountIf[x < 11, B232:G232] + CountIf[x > 29, B232:G232]
A233 = Sequence(Random[1, 6], k, 1, 120)
C233 = CountIf(x ≟ 2, A233)
D233 = CountIf(x ≟ 3, A233)
E233 = CountIf(x ≟ 4, A233)
F233 = CountIf(x ≟ 5, A233)
G233 = CountIf(x ≟ 6, A233)
B233 = CountIf(x ≟ 1, A233)
H233: (B233 - 20)^(2) / 20 + (C233 - 20)^(2) / 20 + (D233 - 20)^(2) / 20 + (E233 - 20)^(2) / 20 + (F233 - 20)^(2) / 20 + (G233 - 20)^(2) / 20
I233 = Sum(abs(B233:G233 - 20))
J233: Max[B233:G233] - Min[B233:G233]
K233 = Max(abs(B233:G233 - 20))
L233: CountIf[x < 11, B233:G233] + CountIf[x > 29, B233:G233]
A234 = Sequence(Random[1, 6], k, 1, 120)
C234 = CountIf(x ≟ 2, A234)
D234 = CountIf(x ≟ 3, A234)
E234 = CountIf(x ≟ 4, A234)
F234 = CountIf(x ≟ 5, A234)
G234 = CountIf(x ≟ 6, A234)
B234 = CountIf(x ≟ 1, A234)
H234: (B234 - 20)^(2) / 20 + (C234 - 20)^(2) / 20 + (D234 - 20)^(2) / 20 + (E234 - 20)^(2) / 20 + (F234 - 20)^(2) / 20 + (G234 - 20)^(2) / 20
I234 = Sum(abs(B234:G234 - 20))
J234: Max[B234:G234] - Min[B234:G234]
K234 = Max(abs(B234:G234 - 20))
L234: CountIf[x < 11, B234:G234] + CountIf[x > 29, B234:G234]
A235 = Sequence(Random[1, 6], k, 1, 120)
C235 = CountIf(x ≟ 2, A235)
D235 = CountIf(x ≟ 3, A235)
E235 = CountIf(x ≟ 4, A235)
F235 = CountIf(x ≟ 5, A235)
G235 = CountIf(x ≟ 6, A235)
B235 = CountIf(x ≟ 1, A235)
H235: (B235 - 20)^(2) / 20 + (C235 - 20)^(2) / 20 + (D235 - 20)^(2) / 20 + (E235 - 20)^(2) / 20 + (F235 - 20)^(2) / 20 + (G235 - 20)^(2) / 20
I235 = Sum(abs(B235:G235 - 20))
J235: Max[B235:G235] - Min[B235:G235]
K235 = Max(abs(B235:G235 - 20))
L235: CountIf[x < 11, B235:G235] + CountIf[x > 29, B235:G235]
A236 = Sequence(Random[1, 6], k, 1, 120)
C236 = CountIf(x ≟ 2, A236)
D236 = CountIf(x ≟ 3, A236)
E236 = CountIf(x ≟ 4, A236)
F236 = CountIf(x ≟ 5, A236)
G236 = CountIf(x ≟ 6, A236)
B236 = CountIf(x ≟ 1, A236)
H236: (B236 - 20)^(2) / 20 + (C236 - 20)^(2) / 20 + (D236 - 20)^(2) / 20 + (E236 - 20)^(2) / 20 + (F236 - 20)^(2) / 20 + (G236 - 20)^(2) / 20
I236 = Sum(abs(B236:G236 - 20))
J236: Max[B236:G236] - Min[B236:G236]
K236 = Max(abs(B236:G236 - 20))
L236: CountIf[x < 11, B236:G236] + CountIf[x > 29, B236:G236]
A237 = Sequence(Random[1, 6], k, 1, 120)
C237 = CountIf(x ≟ 2, A237)
D237 = CountIf(x ≟ 3, A237)
E237 = CountIf(x ≟ 4, A237)
F237 = CountIf(x ≟ 5, A237)
G237 = CountIf(x ≟ 6, A237)
B237 = CountIf(x ≟ 1, A237)
H237: (B237 - 20)^(2) / 20 + (C237 - 20)^(2) / 20 + (D237 - 20)^(2) / 20 + (E237 - 20)^(2) / 20 + (F237 - 20)^(2) / 20 + (G237 - 20)^(2) / 20
I237 = Sum(abs(B237:G237 - 20))
J237: Max[B237:G237] - Min[B237:G237]
K237 = Max(abs(B237:G237 - 20))
L237: CountIf[x < 11, B237:G237] + CountIf[x > 29, B237:G237]
A238 = Sequence(Random[1, 6], k, 1, 120)
C238 = CountIf(x ≟ 2, A238)
D238 = CountIf(x ≟ 3, A238)
E238 = CountIf(x ≟ 4, A238)
F238 = CountIf(x ≟ 5, A238)
G238 = CountIf(x ≟ 6, A238)
B238 = CountIf(x ≟ 1, A238)
H238: (B238 - 20)^(2) / 20 + (C238 - 20)^(2) / 20 + (D238 - 20)^(2) / 20 + (E238 - 20)^(2) / 20 + (F238 - 20)^(2) / 20 + (G238 - 20)^(2) / 20
I238 = Sum(abs(B238:G238 - 20))
J238: Max[B238:G238] - Min[B238:G238]
K238 = Max(abs(B238:G238 - 20))
L238: CountIf[x < 11, B238:G238] + CountIf[x > 29, B238:G238]
A239 = Sequence(Random[1, 6], k, 1, 120)
C239 = CountIf(x ≟ 2, A239)
D239 = CountIf(x ≟ 3, A239)
E239 = CountIf(x ≟ 4, A239)
F239 = CountIf(x ≟ 5, A239)
G239 = CountIf(x ≟ 6, A239)
B239 = CountIf(x ≟ 1, A239)
H239: (B239 - 20)^(2) / 20 + (C239 - 20)^(2) / 20 + (D239 - 20)^(2) / 20 + (E239 - 20)^(2) / 20 + (F239 - 20)^(2) / 20 + (G239 - 20)^(2) / 20
I239 = Sum(abs(B239:G239 - 20))
J239: Max[B239:G239] - Min[B239:G239]
K239 = Max(abs(B239:G239 - 20))
L239: CountIf[x < 11, B239:G239] + CountIf[x > 29, B239:G239]
A240 = Sequence(Random[1, 6], k, 1, 120)
C240 = CountIf(x ≟ 2, A240)
D240 = CountIf(x ≟ 3, A240)
E240 = CountIf(x ≟ 4, A240)
F240 = CountIf(x ≟ 5, A240)
G240 = CountIf(x ≟ 6, A240)
B240 = CountIf(x ≟ 1, A240)
H240: (B240 - 20)^(2) / 20 + (C240 - 20)^(2) / 20 + (D240 - 20)^(2) / 20 + (E240 - 20)^(2) / 20 + (F240 - 20)^(2) / 20 + (G240 - 20)^(2) / 20
I240 = Sum(abs(B240:G240 - 20))
J240: Max[B240:G240] - Min[B240:G240]
K240 = Max(abs(B240:G240 - 20))
L240: CountIf[x < 11, B240:G240] + CountIf[x > 29, B240:G240]
A241 = Sequence(Random[1, 6], k, 1, 120)
C241 = CountIf(x ≟ 2, A241)
D241 = CountIf(x ≟ 3, A241)
E241 = CountIf(x ≟ 4, A241)
F241 = CountIf(x ≟ 5, A241)
G241 = CountIf(x ≟ 6, A241)
B241 = CountIf(x ≟ 1, A241)
H241: (B241 - 20)^(2) / 20 + (C241 - 20)^(2) / 20 + (D241 - 20)^(2) / 20 + (E241 - 20)^(2) / 20 + (F241 - 20)^(2) / 20 + (G241 - 20)^(2) / 20
I241 = Sum(abs(B241:G241 - 20))
J241: Max[B241:G241] - Min[B241:G241]
K241 = Max(abs(B241:G241 - 20))
L241: CountIf[x < 11, B241:G241] + CountIf[x > 29, B241:G241]
A242 = Sequence(Random[1, 6], k, 1, 120)
C242 = CountIf(x ≟ 2, A242)
D242 = CountIf(x ≟ 3, A242)
E242 = CountIf(x ≟ 4, A242)
F242 = CountIf(x ≟ 5, A242)
G242 = CountIf(x ≟ 6, A242)
B242 = CountIf(x ≟ 1, A242)
H242: (B242 - 20)^(2) / 20 + (C242 - 20)^(2) / 20 + (D242 - 20)^(2) / 20 + (E242 - 20)^(2) / 20 + (F242 - 20)^(2) / 20 + (G242 - 20)^(2) / 20
I242 = Sum(abs(B242:G242 - 20))
J242: Max[B242:G242] - Min[B242:G242]
K242 = Max(abs(B242:G242 - 20))
L242: CountIf[x < 11, B242:G242] + CountIf[x > 29, B242:G242]
A243 = Sequence(Random[1, 6], k, 1, 120)
C243 = CountIf(x ≟ 2, A243)
D243 = CountIf(x ≟ 3, A243)
E243 = CountIf(x ≟ 4, A243)
F243 = CountIf(x ≟ 5, A243)
G243 = CountIf(x ≟ 6, A243)
B243 = CountIf(x ≟ 1, A243)
H243: (B243 - 20)^(2) / 20 + (C243 - 20)^(2) / 20 + (D243 - 20)^(2) / 20 + (E243 - 20)^(2) / 20 + (F243 - 20)^(2) / 20 + (G243 - 20)^(2) / 20
I243 = Sum(abs(B243:G243 - 20))
J243: Max[B243:G243] - Min[B243:G243]
K243 = Max(abs(B243:G243 - 20))
L243: CountIf[x < 11, B243:G243] + CountIf[x > 29, B243:G243]
A244 = Sequence(Random[1, 6], k, 1, 120)
C244 = CountIf(x ≟ 2, A244)
D244 = CountIf(x ≟ 3, A244)
E244 = CountIf(x ≟ 4, A244)
F244 = CountIf(x ≟ 5, A244)
G244 = CountIf(x ≟ 6, A244)
B244 = CountIf(x ≟ 1, A244)
H244: (B244 - 20)^(2) / 20 + (C244 - 20)^(2) / 20 + (D244 - 20)^(2) / 20 + (E244 - 20)^(2) / 20 + (F244 - 20)^(2) / 20 + (G244 - 20)^(2) / 20
I244 = Sum(abs(B244:G244 - 20))
J244: Max[B244:G244] - Min[B244:G244]
K244 = Max(abs(B244:G244 - 20))
L244: CountIf[x < 11, B244:G244] + CountIf[x > 29, B244:G244]
A245 = Sequence(Random[1, 6], k, 1, 120)
C245 = CountIf(x ≟ 2, A245)
D245 = CountIf(x ≟ 3, A245)
E245 = CountIf(x ≟ 4, A245)
F245 = CountIf(x ≟ 5, A245)
G245 = CountIf(x ≟ 6, A245)
B245 = CountIf(x ≟ 1, A245)
H245: (B245 - 20)^(2) / 20 + (C245 - 20)^(2) / 20 + (D245 - 20)^(2) / 20 + (E245 - 20)^(2) / 20 + (F245 - 20)^(2) / 20 + (G245 - 20)^(2) / 20
I245 = Sum(abs(B245:G245 - 20))
J245: Max[B245:G245] - Min[B245:G245]
K245 = Max(abs(B245:G245 - 20))
L245: CountIf[x < 11, B245:G245] + CountIf[x > 29, B245:G245]
A246 = Sequence(Random[1, 6], k, 1, 120)
C246 = CountIf(x ≟ 2, A246)
D246 = CountIf(x ≟ 3, A246)
E246 = CountIf(x ≟ 4, A246)
F246 = CountIf(x ≟ 5, A246)
G246 = CountIf(x ≟ 6, A246)
B246 = CountIf(x ≟ 1, A246)
H246: (B246 - 20)^(2) / 20 + (C246 - 20)^(2) / 20 + (D246 - 20)^(2) / 20 + (E246 - 20)^(2) / 20 + (F246 - 20)^(2) / 20 + (G246 - 20)^(2) / 20
I246 = Sum(abs(B246:G246 - 20))
J246: Max[B246:G246] - Min[B246:G246]
K246 = Max(abs(B246:G246 - 20))
L246: CountIf[x < 11, B246:G246] + CountIf[x > 29, B246:G246]
A247 = Sequence(Random[1, 6], k, 1, 120)
C247 = CountIf(x ≟ 2, A247)
D247 = CountIf(x ≟ 3, A247)
E247 = CountIf(x ≟ 4, A247)
F247 = CountIf(x ≟ 5, A247)
G247 = CountIf(x ≟ 6, A247)
B247 = CountIf(x ≟ 1, A247)
H247: (B247 - 20)^(2) / 20 + (C247 - 20)^(2) / 20 + (D247 - 20)^(2) / 20 + (E247 - 20)^(2) / 20 + (F247 - 20)^(2) / 20 + (G247 - 20)^(2) / 20
I247 = Sum(abs(B247:G247 - 20))
J247: Max[B247:G247] - Min[B247:G247]
K247 = Max(abs(B247:G247 - 20))
L247: CountIf[x < 11, B247:G247] + CountIf[x > 29, B247:G247]
A248 = Sequence(Random[1, 6], k, 1, 120)
C248 = CountIf(x ≟ 2, A248)
D248 = CountIf(x ≟ 3, A248)
E248 = CountIf(x ≟ 4, A248)
F248 = CountIf(x ≟ 5, A248)
G248 = CountIf(x ≟ 6, A248)
B248 = CountIf(x ≟ 1, A248)
H248: (B248 - 20)^(2) / 20 + (C248 - 20)^(2) / 20 + (D248 - 20)^(2) / 20 + (E248 - 20)^(2) / 20 + (F248 - 20)^(2) / 20 + (G248 - 20)^(2) / 20
I248 = Sum(abs(B248:G248 - 20))
J248: Max[B248:G248] - Min[B248:G248]
K248 = Max(abs(B248:G248 - 20))
L248: CountIf[x < 11, B248:G248] + CountIf[x > 29, B248:G248]
A249 = Sequence(Random[1, 6], k, 1, 120)
C249 = CountIf(x ≟ 2, A249)
D249 = CountIf(x ≟ 3, A249)
E249 = CountIf(x ≟ 4, A249)
F249 = CountIf(x ≟ 5, A249)
G249 = CountIf(x ≟ 6, A249)
B249 = CountIf(x ≟ 1, A249)
H249: (B249 - 20)^(2) / 20 + (C249 - 20)^(2) / 20 + (D249 - 20)^(2) / 20 + (E249 - 20)^(2) / 20 + (F249 - 20)^(2) / 20 + (G249 - 20)^(2) / 20
I249 = Sum(abs(B249:G249 - 20))
J249: Max[B249:G249] - Min[B249:G249]
K249 = Max(abs(B249:G249 - 20))
L249: CountIf[x < 11, B249:G249] + CountIf[x > 29, B249:G249]
A250 = Sequence(Random[1, 6], k, 1, 120)
C250 = CountIf(x ≟ 2, A250)
D250 = CountIf(x ≟ 3, A250)
E250 = CountIf(x ≟ 4, A250)
F250 = CountIf(x ≟ 5, A250)
G250 = CountIf(x ≟ 6, A250)
B250 = CountIf(x ≟ 1, A250)
H250: (B250 - 20)^(2) / 20 + (C250 - 20)^(2) / 20 + (D250 - 20)^(2) / 20 + (E250 - 20)^(2) / 20 + (F250 - 20)^(2) / 20 + (G250 - 20)^(2) / 20
I250 = Sum(abs(B250:G250 - 20))
J250: Max[B250:G250] - Min[B250:G250]
K250 = Max(abs(B250:G250 - 20))
L250: CountIf[x < 11, B250:G250] + CountIf[x > 29, B250:G250]
A251 = Sequence(Random[1, 6], k, 1, 120)
C251 = CountIf(x ≟ 2, A251)
D251 = CountIf(x ≟ 3, A251)
E251 = CountIf(x ≟ 4, A251)
F251 = CountIf(x ≟ 5, A251)
G251 = CountIf(x ≟ 6, A251)
B251 = CountIf(x ≟ 1, A251)
H251: (B251 - 20)^(2) / 20 + (C251 - 20)^(2) / 20 + (D251 - 20)^(2) / 20 + (E251 - 20)^(2) / 20 + (F251 - 20)^(2) / 20 + (G251 - 20)^(2) / 20
I251 = Sum(abs(B251:G251 - 20))
J251: Max[B251:G251] - Min[B251:G251]
K251 = Max(abs(B251:G251 - 20))
L251: CountIf[x < 11, B251:G251] + CountIf[x > 29, B251:G251]
A252 = Sequence(Random[1, 6], k, 1, 120)
C252 = CountIf(x ≟ 2, A252)
D252 = CountIf(x ≟ 3, A252)
E252 = CountIf(x ≟ 4, A252)
F252 = CountIf(x ≟ 5, A252)
G252 = CountIf(x ≟ 6, A252)
B252 = CountIf(x ≟ 1, A252)
H252: (B252 - 20)^(2) / 20 + (C252 - 20)^(2) / 20 + (D252 - 20)^(2) / 20 + (E252 - 20)^(2) / 20 + (F252 - 20)^(2) / 20 + (G252 - 20)^(2) / 20
I252 = Sum(abs(B252:G252 - 20))
J252: Max[B252:G252] - Min[B252:G252]
K252 = Max(abs(B252:G252 - 20))
L252: CountIf[x < 11, B252:G252] + CountIf[x > 29, B252:G252]
A253 = Sequence(Random[1, 6], k, 1, 120)
C253 = CountIf(x ≟ 2, A253)
D253 = CountIf(x ≟ 3, A253)
E253 = CountIf(x ≟ 4, A253)
F253 = CountIf(x ≟ 5, A253)
G253 = CountIf(x ≟ 6, A253)
B253 = CountIf(x ≟ 1, A253)
H253: (B253 - 20)^(2) / 20 + (C253 - 20)^(2) / 20 + (D253 - 20)^(2) / 20 + (E253 - 20)^(2) / 20 + (F253 - 20)^(2) / 20 + (G253 - 20)^(2) / 20
I253 = Sum(abs(B253:G253 - 20))
J253: Max[B253:G253] - Min[B253:G253]
K253 = Max(abs(B253:G253 - 20))
L253: CountIf[x < 11, B253:G253] + CountIf[x > 29, B253:G253]
A254 = Sequence(Random[1, 6], k, 1, 120)
C254 = CountIf(x ≟ 2, A254)
D254 = CountIf(x ≟ 3, A254)
E254 = CountIf(x ≟ 4, A254)
F254 = CountIf(x ≟ 5, A254)
G254 = CountIf(x ≟ 6, A254)
B254 = CountIf(x ≟ 1, A254)
H254: (B254 - 20)^(2) / 20 + (C254 - 20)^(2) / 20 + (D254 - 20)^(2) / 20 + (E254 - 20)^(2) / 20 + (F254 - 20)^(2) / 20 + (G254 - 20)^(2) / 20
I254 = Sum(abs(B254:G254 - 20))
J254: Max[B254:G254] - Min[B254:G254]
K254 = Max(abs(B254:G254 - 20))
L254: CountIf[x < 11, B254:G254] + CountIf[x > 29, B254:G254]
A255 = Sequence(Random[1, 6], k, 1, 120)
C255 = CountIf(x ≟ 2, A255)
D255 = CountIf(x ≟ 3, A255)
E255 = CountIf(x ≟ 4, A255)
F255 = CountIf(x ≟ 5, A255)
G255 = CountIf(x ≟ 6, A255)
B255 = CountIf(x ≟ 1, A255)
H255: (B255 - 20)^(2) / 20 + (C255 - 20)^(2) / 20 + (D255 - 20)^(2) / 20 + (E255 - 20)^(2) / 20 + (F255 - 20)^(2) / 20 + (G255 - 20)^(2) / 20
I255 = Sum(abs(B255:G255 - 20))
J255: Max[B255:G255] - Min[B255:G255]
K255 = Max(abs(B255:G255 - 20))
L255: CountIf[x < 11, B255:G255] + CountIf[x > 29, B255:G255]
A256 = Sequence(Random[1, 6], k, 1, 120)
C256 = CountIf(x ≟ 2, A256)
D256 = CountIf(x ≟ 3, A256)
E256 = CountIf(x ≟ 4, A256)
F256 = CountIf(x ≟ 5, A256)
G256 = CountIf(x ≟ 6, A256)
B256 = CountIf(x ≟ 1, A256)
H256: (B256 - 20)^(2) / 20 + (C256 - 20)^(2) / 20 + (D256 - 20)^(2) / 20 + (E256 - 20)^(2) / 20 + (F256 - 20)^(2) / 20 + (G256 - 20)^(2) / 20
I256 = Sum(abs(B256:G256 - 20))
J256: Max[B256:G256] - Min[B256:G256]
K256 = Max(abs(B256:G256 - 20))
L256: CountIf[x < 11, B256:G256] + CountIf[x > 29, B256:G256]
A257 = Sequence(Random[1, 6], k, 1, 120)
C257 = CountIf(x ≟ 2, A257)
D257 = CountIf(x ≟ 3, A257)
E257 = CountIf(x ≟ 4, A257)
F257 = CountIf(x ≟ 5, A257)
G257 = CountIf(x ≟ 6, A257)
B257 = CountIf(x ≟ 1, A257)
H257: (B257 - 20)^(2) / 20 + (C257 - 20)^(2) / 20 + (D257 - 20)^(2) / 20 + (E257 - 20)^(2) / 20 + (F257 - 20)^(2) / 20 + (G257 - 20)^(2) / 20
I257 = Sum(abs(B257:G257 - 20))
J257: Max[B257:G257] - Min[B257:G257]
K257 = Max(abs(B257:G257 - 20))
L257: CountIf[x < 11, B257:G257] + CountIf[x > 29, B257:G257]
A258 = Sequence(Random[1, 6], k, 1, 120)
C258 = CountIf(x ≟ 2, A258)
D258 = CountIf(x ≟ 3, A258)
E258 = CountIf(x ≟ 4, A258)
F258 = CountIf(x ≟ 5, A258)
G258 = CountIf(x ≟ 6, A258)
B258 = CountIf(x ≟ 1, A258)
H258: (B258 - 20)^(2) / 20 + (C258 - 20)^(2) / 20 + (D258 - 20)^(2) / 20 + (E258 - 20)^(2) / 20 + (F258 - 20)^(2) / 20 + (G258 - 20)^(2) / 20
I258 = Sum(abs(B258:G258 - 20))
J258: Max[B258:G258] - Min[B258:G258]
K258 = Max(abs(B258:G258 - 20))
L258: CountIf[x < 11, B258:G258] + CountIf[x > 29, B258:G258]
A259 = Sequence(Random[1, 6], k, 1, 120)
C259 = CountIf(x ≟ 2, A259)
D259 = CountIf(x ≟ 3, A259)
E259 = CountIf(x ≟ 4, A259)
F259 = CountIf(x ≟ 5, A259)
G259 = CountIf(x ≟ 6, A259)
B259 = CountIf(x ≟ 1, A259)
H259: (B259 - 20)^(2) / 20 + (C259 - 20)^(2) / 20 + (D259 - 20)^(2) / 20 + (E259 - 20)^(2) / 20 + (F259 - 20)^(2) / 20 + (G259 - 20)^(2) / 20
I259 = Sum(abs(B259:G259 - 20))
J259: Max[B259:G259] - Min[B259:G259]
K259 = Max(abs(B259:G259 - 20))
L259: CountIf[x < 11, B259:G259] + CountIf[x > 29, B259:G259]
A260 = Sequence(Random[1, 6], k, 1, 120)
C260 = CountIf(x ≟ 2, A260)
D260 = CountIf(x ≟ 3, A260)
E260 = CountIf(x ≟ 4, A260)
F260 = CountIf(x ≟ 5, A260)
G260 = CountIf(x ≟ 6, A260)
B260 = CountIf(x ≟ 1, A260)
H260: (B260 - 20)^(2) / 20 + (C260 - 20)^(2) / 20 + (D260 - 20)^(2) / 20 + (E260 - 20)^(2) / 20 + (F260 - 20)^(2) / 20 + (G260 - 20)^(2) / 20
I260 = Sum(abs(B260:G260 - 20))
J260: Max[B260:G260] - Min[B260:G260]
K260 = Max(abs(B260:G260 - 20))
L260: CountIf[x < 11, B260:G260] + CountIf[x > 29, B260:G260]
A261 = Sequence(Random[1, 6], k, 1, 120)
C261 = CountIf(x ≟ 2, A261)
D261 = CountIf(x ≟ 3, A261)
E261 = CountIf(x ≟ 4, A261)
F261 = CountIf(x ≟ 5, A261)
G261 = CountIf(x ≟ 6, A261)
B261 = CountIf(x ≟ 1, A261)
H261: (B261 - 20)^(2) / 20 + (C261 - 20)^(2) / 20 + (D261 - 20)^(2) / 20 + (E261 - 20)^(2) / 20 + (F261 - 20)^(2) / 20 + (G261 - 20)^(2) / 20
I261 = Sum(abs(B261:G261 - 20))
J261: Max[B261:G261] - Min[B261:G261]
K261 = Max(abs(B261:G261 - 20))
L261: CountIf[x < 11, B261:G261] + CountIf[x > 29, B261:G261]
I262 = Sum(abs(B262:G262 - 20))
J262: Max[B262:G262] - Min[B262:G262]
K262 = Max(abs(B262:G262 - 20))
L262: CountIf[x < 11, B262:G262] + CountIf[x > 29, B262:G262]
A263 = Sequence(Random[1, 6], k, 1, 120)
C263 = CountIf(x ≟ 2, A263)
D263 = CountIf(x ≟ 3, A263)
E263 = CountIf(x ≟ 4, A263)
F263 = CountIf(x ≟ 5, A263)
G263 = CountIf(x ≟ 6, A263)
B263 = CountIf(x ≟ 1, A263)
H263: (B263 - 20)^(2) / 20 + (C263 - 20)^(2) / 20 + (D263 - 20)^(2) / 20 + (E263 - 20)^(2) / 20 + (F263 - 20)^(2) / 20 + (G263 - 20)^(2) / 20
I263 = Sum(abs(B263:G263 - 20))
J263: Max[B263:G263] - Min[B263:G263]
K263 = Max(abs(B263:G263 - 20))
L263: CountIf[x < 11, B263:G263] + CountIf[x > 29, B263:G263]
A264 = Sequence(Random[1, 6], k, 1, 120)
C264 = CountIf(x ≟ 2, A264)
D264 = CountIf(x ≟ 3, A264)
E264 = CountIf(x ≟ 4, A264)
F264 = CountIf(x ≟ 5, A264)
G264 = CountIf(x ≟ 6, A264)
B264 = CountIf(x ≟ 1, A264)
H264: (B264 - 20)^(2) / 20 + (C264 - 20)^(2) / 20 + (D264 - 20)^(2) / 20 + (E264 - 20)^(2) / 20 + (F264 - 20)^(2) / 20 + (G264 - 20)^(2) / 20
I264 = Sum(abs(B264:G264 - 20))
J264: Max[B264:G264] - Min[B264:G264]
K264 = Max(abs(B264:G264 - 20))
L264: CountIf[x < 11, B264:G264] + CountIf[x > 29, B264:G264]
A265 = Sequence(Random[1, 6], k, 1, 120)
C265 = CountIf(x ≟ 2, A265)
D265 = CountIf(x ≟ 3, A265)
E265 = CountIf(x ≟ 4, A265)
F265 = CountIf(x ≟ 5, A265)
G265 = CountIf(x ≟ 6, A265)
B265 = CountIf(x ≟ 1, A265)
H265: (B265 - 20)^(2) / 20 + (C265 - 20)^(2) / 20 + (D265 - 20)^(2) / 20 + (E265 - 20)^(2) / 20 + (F265 - 20)^(2) / 20 + (G265 - 20)^(2) / 20
I265 = Sum(abs(B265:G265 - 20))
J265: Max[B265:G265] - Min[B265:G265]
K265 = Max(abs(B265:G265 - 20))
L265: CountIf[x < 11, B265:G265] + CountIf[x > 29, B265:G265]
A266 = Sequence(Random[1, 6], k, 1, 120)
C266 = CountIf(x ≟ 2, A266)
D266 = CountIf(x ≟ 3, A266)
E266 = CountIf(x ≟ 4, A266)
F266 = CountIf(x ≟ 5, A266)
G266 = CountIf(x ≟ 6, A266)
B266 = CountIf(x ≟ 1, A266)
H266: (B266 - 20)^(2) / 20 + (C266 - 20)^(2) / 20 + (D266 - 20)^(2) / 20 + (E266 - 20)^(2) / 20 + (F266 - 20)^(2) / 20 + (G266 - 20)^(2) / 20
I266 = Sum(abs(B266:G266 - 20))
J266: Max[B266:G266] - Min[B266:G266]
K266 = Max(abs(B266:G266 - 20))
L266: CountIf[x < 11, B266:G266] + CountIf[x > 29, B266:G266]
A267 = Sequence(Random[1, 6], k, 1, 120)
C267 = CountIf(x ≟ 2, A267)
D267 = CountIf(x ≟ 3, A267)
E267 = CountIf(x ≟ 4, A267)
F267 = CountIf(x ≟ 5, A267)
G267 = CountIf(x ≟ 6, A267)
B267 = CountIf(x ≟ 1, A267)
H267: (B267 - 20)^(2) / 20 + (C267 - 20)^(2) / 20 + (D267 - 20)^(2) / 20 + (E267 - 20)^(2) / 20 + (F267 - 20)^(2) / 20 + (G267 - 20)^(2) / 20
I267 = Sum(abs(B267:G267 - 20))
J267: Max[B267:G267] - Min[B267:G267]
K267 = Max(abs(B267:G267 - 20))
L267: CountIf[x < 11, B267:G267] + CountIf[x > 29, B267:G267]
A268 = Sequence(Random[1, 6], k, 1, 120)
C268 = CountIf(x ≟ 2, A268)
D268 = CountIf(x ≟ 3, A268)
E268 = CountIf(x ≟ 4, A268)
F268 = CountIf(x ≟ 5, A268)
G268 = CountIf(x ≟ 6, A268)
B268 = CountIf(x ≟ 1, A268)
H268: (B268 - 20)^(2) / 20 + (C268 - 20)^(2) / 20 + (D268 - 20)^(2) / 20 + (E268 - 20)^(2) / 20 + (F268 - 20)^(2) / 20 + (G268 - 20)^(2) / 20
I268 = Sum(abs(B268:G268 - 20))
J268: Max[B268:G268] - Min[B268:G268]
K268 = Max(abs(B268:G268 - 20))
L268: CountIf[x < 11, B268:G268] + CountIf[x > 29, B268:G268]
A269 = Sequence(Random[1, 6], k, 1, 120)
C269 = CountIf(x ≟ 2, A269)
D269 = CountIf(x ≟ 3, A269)
E269 = CountIf(x ≟ 4, A269)
F269 = CountIf(x ≟ 5, A269)
G269 = CountIf(x ≟ 6, A269)
B269 = CountIf(x ≟ 1, A269)
H269: (B269 - 20)^(2) / 20 + (C269 - 20)^(2) / 20 + (D269 - 20)^(2) / 20 + (E269 - 20)^(2) / 20 + (F269 - 20)^(2) / 20 + (G269 - 20)^(2) / 20
I269 = Sum(abs(B269:G269 - 20))
J269: Max[B269:G269] - Min[B269:G269]
K269 = Max(abs(B269:G269 - 20))
L269: CountIf[x < 11, B269:G269] + CountIf[x > 29, B269:G269]
A270 = Sequence(Random[1, 6], k, 1, 120)
C270 = CountIf(x ≟ 2, A270)
D270 = CountIf(x ≟ 3, A270)
E270 = CountIf(x ≟ 4, A270)
F270 = CountIf(x ≟ 5, A270)
G270 = CountIf(x ≟ 6, A270)
B270 = CountIf(x ≟ 1, A270)
H270: (B270 - 20)^(2) / 20 + (C270 - 20)^(2) / 20 + (D270 - 20)^(2) / 20 + (E270 - 20)^(2) / 20 + (F270 - 20)^(2) / 20 + (G270 - 20)^(2) / 20
I270 = Sum(abs(B270:G270 - 20))
J270: Max[B270:G270] - Min[B270:G270]
K270 = Max(abs(B270:G270 - 20))
L270: CountIf[x < 11, B270:G270] + CountIf[x > 29, B270:G270]
A271 = Sequence(Random[1, 6], k, 1, 120)
C271 = CountIf(x ≟ 2, A271)
D271 = CountIf(x ≟ 3, A271)
E271 = CountIf(x ≟ 4, A271)
F271 = CountIf(x ≟ 5, A271)
G271 = CountIf(x ≟ 6, A271)
B271 = CountIf(x ≟ 1, A271)
H271: (B271 - 20)^(2) / 20 + (C271 - 20)^(2) / 20 + (D271 - 20)^(2) / 20 + (E271 - 20)^(2) / 20 + (F271 - 20)^(2) / 20 + (G271 - 20)^(2) / 20
I271 = Sum(abs(B271:G271 - 20))
J271: Max[B271:G271] - Min[B271:G271]
K271 = Max(abs(B271:G271 - 20))
L271: CountIf[x < 11, B271:G271] + CountIf[x > 29, B271:G271]
A272 = Sequence(Random[1, 6], k, 1, 120)
C272 = CountIf(x ≟ 2, A272)
D272 = CountIf(x ≟ 3, A272)
E272 = CountIf(x ≟ 4, A272)
F272 = CountIf(x ≟ 5, A272)
G272 = CountIf(x ≟ 6, A272)
B272 = CountIf(x ≟ 1, A272)
H272: (B272 - 20)^(2) / 20 + (C272 - 20)^(2) / 20 + (D272 - 20)^(2) / 20 + (E272 - 20)^(2) / 20 + (F272 - 20)^(2) / 20 + (G272 - 20)^(2) / 20
I272 = Sum(abs(B272:G272 - 20))
J272: Max[B272:G272] - Min[B272:G272]
K272 = Max(abs(B272:G272 - 20))
L272: CountIf[x < 11, B272:G272] + CountIf[x > 29, B272:G272]
A273 = Sequence(Random[1, 6], k, 1, 120)
C273 = CountIf(x ≟ 2, A273)
D273 = CountIf(x ≟ 3, A273)
E273 = CountIf(x ≟ 4, A273)
F273 = CountIf(x ≟ 5, A273)
G273 = CountIf(x ≟ 6, A273)
B273 = CountIf(x ≟ 1, A273)
H273: (B273 - 20)^(2) / 20 + (C273 - 20)^(2) / 20 + (D273 - 20)^(2) / 20 + (E273 - 20)^(2) / 20 + (F273 - 20)^(2) / 20 + (G273 - 20)^(2) / 20
I273 = Sum(abs(B273:G273 - 20))
J273: Max[B273:G273] - Min[B273:G273]
K273 = Max(abs(B273:G273 - 20))
L273: CountIf[x < 11, B273:G273] + CountIf[x > 29, B273:G273]
A274 = Sequence(Random[1, 6], k, 1, 120)
C274 = CountIf(x ≟ 2, A274)
D274 = CountIf(x ≟ 3, A274)
E274 = CountIf(x ≟ 4, A274)
F274 = CountIf(x ≟ 5, A274)
G274 = CountIf(x ≟ 6, A274)
B274 = CountIf(x ≟ 1, A274)
H274: (B274 - 20)^(2) / 20 + (C274 - 20)^(2) / 20 + (D274 - 20)^(2) / 20 + (E274 - 20)^(2) / 20 + (F274 - 20)^(2) / 20 + (G274 - 20)^(2) / 20
I274 = Sum(abs(B274:G274 - 20))
J274: Max[B274:G274] - Min[B274:G274]
K274 = Max(abs(B274:G274 - 20))
L274: CountIf[x < 11, B274:G274] + CountIf[x > 29, B274:G274]
A275 = Sequence(Random[1, 6], k, 1, 120)
C275 = CountIf(x ≟ 2, A275)
D275 = CountIf(x ≟ 3, A275)
E275 = CountIf(x ≟ 4, A275)
F275 = CountIf(x ≟ 5, A275)
G275 = CountIf(x ≟ 6, A275)
B275 = CountIf(x ≟ 1, A275)
H275: (B275 - 20)^(2) / 20 + (C275 - 20)^(2) / 20 + (D275 - 20)^(2) / 20 + (E275 - 20)^(2) / 20 + (F275 - 20)^(2) / 20 + (G275 - 20)^(2) / 20
I275 = Sum(abs(B275:G275 - 20))
J275: Max[B275:G275] - Min[B275:G275]
K275 = Max(abs(B275:G275 - 20))
L275: CountIf[x < 11, B275:G275] + CountIf[x > 29, B275:G275]
A276 = Sequence(Random[1, 6], k, 1, 120)
C276 = CountIf(x ≟ 2, A276)
D276 = CountIf(x ≟ 3, A276)
E276 = CountIf(x ≟ 4, A276)
F276 = CountIf(x ≟ 5, A276)
G276 = CountIf(x ≟ 6, A276)
B276 = CountIf(x ≟ 1, A276)
H276: (B276 - 20)^(2) / 20 + (C276 - 20)^(2) / 20 + (D276 - 20)^(2) / 20 + (E276 - 20)^(2) / 20 + (F276 - 20)^(2) / 20 + (G276 - 20)^(2) / 20
I276 = Sum(abs(B276:G276 - 20))
J276: Max[B276:G276] - Min[B276:G276]
K276 = Max(abs(B276:G276 - 20))
L276: CountIf[x < 11, B276:G276] + CountIf[x > 29, B276:G276]
A277 = Sequence(Random[1, 6], k, 1, 120)
C277 = CountIf(x ≟ 2, A277)
D277 = CountIf(x ≟ 3, A277)
E277 = CountIf(x ≟ 4, A277)
F277 = CountIf(x ≟ 5, A277)
G277 = CountIf(x ≟ 6, A277)
B277 = CountIf(x ≟ 1, A277)
H277: (B277 - 20)^(2) / 20 + (C277 - 20)^(2) / 20 + (D277 - 20)^(2) / 20 + (E277 - 20)^(2) / 20 + (F277 - 20)^(2) / 20 + (G277 - 20)^(2) / 20
I277 = Sum(abs(B277:G277 - 20))
J277: Max[B277:G277] - Min[B277:G277]
K277 = Max(abs(B277:G277 - 20))
L277: CountIf[x < 11, B277:G277] + CountIf[x > 29, B277:G277]
A278 = Sequence(Random[1, 6], k, 1, 120)
C278 = CountIf(x ≟ 2, A278)
D278 = CountIf(x ≟ 3, A278)
E278 = CountIf(x ≟ 4, A278)
F278 = CountIf(x ≟ 5, A278)
G278 = CountIf(x ≟ 6, A278)
B278 = CountIf(x ≟ 1, A278)
H278: (B278 - 20)^(2) / 20 + (C278 - 20)^(2) / 20 + (D278 - 20)^(2) / 20 + (E278 - 20)^(2) / 20 + (F278 - 20)^(2) / 20 + (G278 - 20)^(2) / 20
I278 = Sum(abs(B278:G278 - 20))
J278: Max[B278:G278] - Min[B278:G278]
K278 = Max(abs(B278:G278 - 20))
L278: CountIf[x < 11, B278:G278] + CountIf[x > 29, B278:G278]
A279 = Sequence(Random[1, 6], k, 1, 120)
C279 = CountIf(x ≟ 2, A279)
D279 = CountIf(x ≟ 3, A279)
E279 = CountIf(x ≟ 4, A279)
F279 = CountIf(x ≟ 5, A279)
G279 = CountIf(x ≟ 6, A279)
B279 = CountIf(x ≟ 1, A279)
H279: (B279 - 20)^(2) / 20 + (C279 - 20)^(2) / 20 + (D279 - 20)^(2) / 20 + (E279 - 20)^(2) / 20 + (F279 - 20)^(2) / 20 + (G279 - 20)^(2) / 20
I279 = Sum(abs(B279:G279 - 20))
J279: Max[B279:G279] - Min[B279:G279]
K279 = Max(abs(B279:G279 - 20))
L279: CountIf[x < 11, B279:G279] + CountIf[x > 29, B279:G279]
A280 = Sequence(Random[1, 6], k, 1, 120)
C280 = CountIf(x ≟ 2, A280)
D280 = CountIf(x ≟ 3, A280)
E280 = CountIf(x ≟ 4, A280)
F280 = CountIf(x ≟ 5, A280)
G280 = CountIf(x ≟ 6, A280)
B280 = CountIf(x ≟ 1, A280)
H280: (B280 - 20)^(2) / 20 + (C280 - 20)^(2) / 20 + (D280 - 20)^(2) / 20 + (E280 - 20)^(2) / 20 + (F280 - 20)^(2) / 20 + (G280 - 20)^(2) / 20
I280 = Sum(abs(B280:G280 - 20))
J280: Max[B280:G280] - Min[B280:G280]
K280 = Max(abs(B280:G280 - 20))
L280: CountIf[x < 11, B280:G280] + CountIf[x > 29, B280:G280]
A281 = Sequence(Random[1, 6], k, 1, 120)
C281 = CountIf(x ≟ 2, A281)
D281 = CountIf(x ≟ 3, A281)
E281 = CountIf(x ≟ 4, A281)
F281 = CountIf(x ≟ 5, A281)
G281 = CountIf(x ≟ 6, A281)
B281 = CountIf(x ≟ 1, A281)
H281: (B281 - 20)^(2) / 20 + (C281 - 20)^(2) / 20 + (D281 - 20)^(2) / 20 + (E281 - 20)^(2) / 20 + (F281 - 20)^(2) / 20 + (G281 - 20)^(2) / 20
I281 = Sum(abs(B281:G281 - 20))
J281: Max[B281:G281] - Min[B281:G281]
K281 = Max(abs(B281:G281 - 20))
L281: CountIf[x < 11, B281:G281] + CountIf[x > 29, B281:G281]
A282 = Sequence(Random[1, 6], k, 1, 120)
C282 = CountIf(x ≟ 2, A282)
D282 = CountIf(x ≟ 3, A282)
E282 = CountIf(x ≟ 4, A282)
F282 = CountIf(x ≟ 5, A282)
G282 = CountIf(x ≟ 6, A282)
B282 = CountIf(x ≟ 1, A282)
H282: (B282 - 20)^(2) / 20 + (C282 - 20)^(2) / 20 + (D282 - 20)^(2) / 20 + (E282 - 20)^(2) / 20 + (F282 - 20)^(2) / 20 + (G282 - 20)^(2) / 20
I282 = Sum(abs(B282:G282 - 20))
J282: Max[B282:G282] - Min[B282:G282]
K282 = Max(abs(B282:G282 - 20))
L282: CountIf[x < 11, B282:G282] + CountIf[x > 29, B282:G282]
A283 = Sequence(Random[1, 6], k, 1, 120)
C283 = CountIf(x ≟ 2, A283)
D283 = CountIf(x ≟ 3, A283)
E283 = CountIf(x ≟ 4, A283)
F283 = CountIf(x ≟ 5, A283)
G283 = CountIf(x ≟ 6, A283)
B283 = CountIf(x ≟ 1, A283)
H283: (B283 - 20)^(2) / 20 + (C283 - 20)^(2) / 20 + (D283 - 20)^(2) / 20 + (E283 - 20)^(2) / 20 + (F283 - 20)^(2) / 20 + (G283 - 20)^(2) / 20
I283 = Sum(abs(B283:G283 - 20))
J283: Max[B283:G283] - Min[B283:G283]
K283 = Max(abs(B283:G283 - 20))
L283: CountIf[x < 11, B283:G283] + CountIf[x > 29, B283:G283]
A284 = Sequence(Random[1, 6], k, 1, 120)
C284 = CountIf(x ≟ 2, A284)
D284 = CountIf(x ≟ 3, A284)
E284 = CountIf(x ≟ 4, A284)
F284 = CountIf(x ≟ 5, A284)
G284 = CountIf(x ≟ 6, A284)
B284 = CountIf(x ≟ 1, A284)
H284: (B284 - 20)^(2) / 20 + (C284 - 20)^(2) / 20 + (D284 - 20)^(2) / 20 + (E284 - 20)^(2) / 20 + (F284 - 20)^(2) / 20 + (G284 - 20)^(2) / 20
I284 = Sum(abs(B284:G284 - 20))
J284: Max[B284:G284] - Min[B284:G284]
K284 = Max(abs(B284:G284 - 20))
L284: CountIf[x < 11, B284:G284] + CountIf[x > 29, B284:G284]
A285 = Sequence(Random[1, 6], k, 1, 120)
C285 = CountIf(x ≟ 2, A285)
D285 = CountIf(x ≟ 3, A285)
E285 = CountIf(x ≟ 4, A285)
F285 = CountIf(x ≟ 5, A285)
G285 = CountIf(x ≟ 6, A285)
B285 = CountIf(x ≟ 1, A285)
H285: (B285 - 20)^(2) / 20 + (C285 - 20)^(2) / 20 + (D285 - 20)^(2) / 20 + (E285 - 20)^(2) / 20 + (F285 - 20)^(2) / 20 + (G285 - 20)^(2) / 20
I285 = Sum(abs(B285:G285 - 20))
J285: Max[B285:G285] - Min[B285:G285]
K285 = Max(abs(B285:G285 - 20))
L285: CountIf[x < 11, B285:G285] + CountIf[x > 29, B285:G285]
A286 = Sequence(Random[1, 6], k, 1, 120)
C286 = CountIf(x ≟ 2, A286)
D286 = CountIf(x ≟ 3, A286)
E286 = CountIf(x ≟ 4, A286)
F286 = CountIf(x ≟ 5, A286)
G286 = CountIf(x ≟ 6, A286)
B286 = CountIf(x ≟ 1, A286)
H286: (B286 - 20)^(2) / 20 + (C286 - 20)^(2) / 20 + (D286 - 20)^(2) / 20 + (E286 - 20)^(2) / 20 + (F286 - 20)^(2) / 20 + (G286 - 20)^(2) / 20
I286 = Sum(abs(B286:G286 - 20))
J286: Max[B286:G286] - Min[B286:G286]
K286 = Max(abs(B286:G286 - 20))
L286: CountIf[x < 11, B286:G286] + CountIf[x > 29, B286:G286]
A287 = Sequence(Random[1, 6], k, 1, 120)
C287 = CountIf(x ≟ 2, A287)
D287 = CountIf(x ≟ 3, A287)
E287 = CountIf(x ≟ 4, A287)
F287 = CountIf(x ≟ 5, A287)
G287 = CountIf(x ≟ 6, A287)
B287 = CountIf(x ≟ 1, A287)
H287: (B287 - 20)^(2) / 20 + (C287 - 20)^(2) / 20 + (D287 - 20)^(2) / 20 + (E287 - 20)^(2) / 20 + (F287 - 20)^(2) / 20 + (G287 - 20)^(2) / 20
I287 = Sum(abs(B287:G287 - 20))
J287: Max[B287:G287] - Min[B287:G287]
K287 = Max(abs(B287:G287 - 20))
L287: CountIf[x < 11, B287:G287] + CountIf[x > 29, B287:G287]
A288 = Sequence(Random[1, 6], k, 1, 120)
C288 = CountIf(x ≟ 2, A288)
D288 = CountIf(x ≟ 3, A288)
E288 = CountIf(x ≟ 4, A288)
F288 = CountIf(x ≟ 5, A288)
G288 = CountIf(x ≟ 6, A288)
B288 = CountIf(x ≟ 1, A288)
H288: (B288 - 20)^(2) / 20 + (C288 - 20)^(2) / 20 + (D288 - 20)^(2) / 20 + (E288 - 20)^(2) / 20 + (F288 - 20)^(2) / 20 + (G288 - 20)^(2) / 20
I288 = Sum(abs(B288:G288 - 20))
J288: Max[B288:G288] - Min[B288:G288]
K288 = Max(abs(B288:G288 - 20))
L288: CountIf[x < 11, B288:G288] + CountIf[x > 29, B288:G288]
A289 = Sequence(Random[1, 6], k, 1, 120)
C289 = CountIf(x ≟ 2, A289)
D289 = CountIf(x ≟ 3, A289)
E289 = CountIf(x ≟ 4, A289)
F289 = CountIf(x ≟ 5, A289)
G289 = CountIf(x ≟ 6, A289)
B289 = CountIf(x ≟ 1, A289)
H289: (B289 - 20)^(2) / 20 + (C289 - 20)^(2) / 20 + (D289 - 20)^(2) / 20 + (E289 - 20)^(2) / 20 + (F289 - 20)^(2) / 20 + (G289 - 20)^(2) / 20
I289 = Sum(abs(B289:G289 - 20))
J289: Max[B289:G289] - Min[B289:G289]
K289 = Max(abs(B289:G289 - 20))
L289: CountIf[x < 11, B289:G289] + CountIf[x > 29, B289:G289]
A290 = Sequence(Random[1, 6], k, 1, 120)
C290 = CountIf(x ≟ 2, A290)
D290 = CountIf(x ≟ 3, A290)
E290 = CountIf(x ≟ 4, A290)
F290 = CountIf(x ≟ 5, A290)
G290 = CountIf(x ≟ 6, A290)
B290 = CountIf(x ≟ 1, A290)
H290: (B290 - 20)^(2) / 20 + (C290 - 20)^(2) / 20 + (D290 - 20)^(2) / 20 + (E290 - 20)^(2) / 20 + (F290 - 20)^(2) / 20 + (G290 - 20)^(2) / 20
I290 = Sum(abs(B290:G290 - 20))
J290: Max[B290:G290] - Min[B290:G290]
K290 = Max(abs(B290:G290 - 20))
L290: CountIf[x < 11, B290:G290] + CountIf[x > 29, B290:G290]
A291 = Sequence(Random[1, 6], k, 1, 120)
C291 = CountIf(x ≟ 2, A291)
D291 = CountIf(x ≟ 3, A291)
E291 = CountIf(x ≟ 4, A291)
F291 = CountIf(x ≟ 5, A291)
G291 = CountIf(x ≟ 6, A291)
B291 = CountIf(x ≟ 1, A291)
H291: (B291 - 20)^(2) / 20 + (C291 - 20)^(2) / 20 + (D291 - 20)^(2) / 20 + (E291 - 20)^(2) / 20 + (F291 - 20)^(2) / 20 + (G291 - 20)^(2) / 20
I291 = Sum(abs(B291:G291 - 20))
J291: Max[B291:G291] - Min[B291:G291]
K291 = Max(abs(B291:G291 - 20))
L291: CountIf[x < 11, B291:G291] + CountIf[x > 29, B291:G291]
A292 = Sequence(Random[1, 6], k, 1, 120)
C292 = CountIf(x ≟ 2, A292)
D292 = CountIf(x ≟ 3, A292)
E292 = CountIf(x ≟ 4, A292)
F292 = CountIf(x ≟ 5, A292)
G292 = CountIf(x ≟ 6, A292)
B292 = CountIf(x ≟ 1, A292)
H292: (B292 - 20)^(2) / 20 + (C292 - 20)^(2) / 20 + (D292 - 20)^(2) / 20 + (E292 - 20)^(2) / 20 + (F292 - 20)^(2) / 20 + (G292 - 20)^(2) / 20
I292 = Sum(abs(B292:G292 - 20))
J292: Max[B292:G292] - Min[B292:G292]
K292 = Max(abs(B292:G292 - 20))
L292: CountIf[x < 11, B292:G292] + CountIf[x > 29, B292:G292]
A293 = Sequence(Random[1, 6], k, 1, 120)
C293 = CountIf(x ≟ 2, A293)
D293 = CountIf(x ≟ 3, A293)
E293 = CountIf(x ≟ 4, A293)
F293 = CountIf(x ≟ 5, A293)
G293 = CountIf(x ≟ 6, A293)
B293 = CountIf(x ≟ 1, A293)
H293: (B293 - 20)^(2) / 20 + (C293 - 20)^(2) / 20 + (D293 - 20)^(2) / 20 + (E293 - 20)^(2) / 20 + (F293 - 20)^(2) / 20 + (G293 - 20)^(2) / 20
I293 = Sum(abs(B293:G293 - 20))
J293: Max[B293:G293] - Min[B293:G293]
K293 = Max(abs(B293:G293 - 20))
L293: CountIf[x < 11, B293:G293] + CountIf[x > 29, B293:G293]
A294 = Sequence(Random[1, 6], k, 1, 120)
C294 = CountIf(x ≟ 2, A294)
D294 = CountIf(x ≟ 3, A294)
E294 = CountIf(x ≟ 4, A294)
F294 = CountIf(x ≟ 5, A294)
G294 = CountIf(x ≟ 6, A294)
B294 = CountIf(x ≟ 1, A294)
H294: (B294 - 20)^(2) / 20 + (C294 - 20)^(2) / 20 + (D294 - 20)^(2) / 20 + (E294 - 20)^(2) / 20 + (F294 - 20)^(2) / 20 + (G294 - 20)^(2) / 20
I294 = Sum(abs(B294:G294 - 20))
J294: Max[B294:G294] - Min[B294:G294]
K294 = Max(abs(B294:G294 - 20))
L294: CountIf[x < 11, B294:G294] + CountIf[x > 29, B294:G294]
A295 = Sequence(Random[1, 6], k, 1, 120)
C295 = CountIf(x ≟ 2, A295)
D295 = CountIf(x ≟ 3, A295)
E295 = CountIf(x ≟ 4, A295)
F295 = CountIf(x ≟ 5, A295)
G295 = CountIf(x ≟ 6, A295)
B295 = CountIf(x ≟ 1, A295)
H295: (B295 - 20)^(2) / 20 + (C295 - 20)^(2) / 20 + (D295 - 20)^(2) / 20 + (E295 - 20)^(2) / 20 + (F295 - 20)^(2) / 20 + (G295 - 20)^(2) / 20
I295 = Sum(abs(B295:G295 - 20))
J295: Max[B295:G295] - Min[B295:G295]
K295 = Max(abs(B295:G295 - 20))
L295: CountIf[x < 11, B295:G295] + CountIf[x > 29, B295:G295]
A296 = Sequence(Random[1, 6], k, 1, 120)
C296 = CountIf(x ≟ 2, A296)
D296 = CountIf(x ≟ 3, A296)
E296 = CountIf(x ≟ 4, A296)
F296 = CountIf(x ≟ 5, A296)
G296 = CountIf(x ≟ 6, A296)
B296 = CountIf(x ≟ 1, A296)
H296: (B296 - 20)^(2) / 20 + (C296 - 20)^(2) / 20 + (D296 - 20)^(2) / 20 + (E296 - 20)^(2) / 20 + (F296 - 20)^(2) / 20 + (G296 - 20)^(2) / 20
I296 = Sum(abs(B296:G296 - 20))
J296: Max[B296:G296] - Min[B296:G296]
K296 = Max(abs(B296:G296 - 20))
L296: CountIf[x < 11, B296:G296] + CountIf[x > 29, B296:G296]
A297 = Sequence(Random[1, 6], k, 1, 120)
C297 = CountIf(x ≟ 2, A297)
D297 = CountIf(x ≟ 3, A297)
E297 = CountIf(x ≟ 4, A297)
F297 = CountIf(x ≟ 5, A297)
G297 = CountIf(x ≟ 6, A297)
B297 = CountIf(x ≟ 1, A297)
H297: (B297 - 20)^(2) / 20 + (C297 - 20)^(2) / 20 + (D297 - 20)^(2) / 20 + (E297 - 20)^(2) / 20 + (F297 - 20)^(2) / 20 + (G297 - 20)^(2) / 20
I297 = Sum(abs(B297:G297 - 20))
J297: Max[B297:G297] - Min[B297:G297]
K297 = Max(abs(B297:G297 - 20))
L297: CountIf[x < 11, B297:G297] + CountIf[x > 29, B297:G297]
A298 = Sequence(Random[1, 6], k, 1, 120)
C298 = CountIf(x ≟ 2, A298)
D298 = CountIf(x ≟ 3, A298)
E298 = CountIf(x ≟ 4, A298)
F298 = CountIf(x ≟ 5, A298)
G298 = CountIf(x ≟ 6, A298)
B298 = CountIf(x ≟ 1, A298)
H298: (B298 - 20)^(2) / 20 + (C298 - 20)^(2) / 20 + (D298 - 20)^(2) / 20 + (E298 - 20)^(2) / 20 + (F298 - 20)^(2) / 20 + (G298 - 20)^(2) / 20
I298 = Sum(abs(B298:G298 - 20))
J298: Max[B298:G298] - Min[B298:G298]
K298 = Max(abs(B298:G298 - 20))
L298: CountIf[x < 11, B298:G298] + CountIf[x > 29, B298:G298]
A299 = Sequence(Random[1, 6], k, 1, 120)
C299 = CountIf(x ≟ 2, A299)
D299 = CountIf(x ≟ 3, A299)
E299 = CountIf(x ≟ 4, A299)
F299 = CountIf(x ≟ 5, A299)
G299 = CountIf(x ≟ 6, A299)
B299 = CountIf(x ≟ 1, A299)
H299: (B299 - 20)^(2) / 20 + (C299 - 20)^(2) / 20 + (D299 - 20)^(2) / 20 + (E299 - 20)^(2) / 20 + (F299 - 20)^(2) / 20 + (G299 - 20)^(2) / 20
I299 = Sum(abs(B299:G299 - 20))
J299: Max[B299:G299] - Min[B299:G299]
K299 = Max(abs(B299:G299 - 20))
L299: CountIf[x < 11, B299:G299] + CountIf[x > 29, B299:G299]
A300 = Sequence(Random[1, 6], k, 1, 120)
C300 = CountIf(x ≟ 2, A300)
D300 = CountIf(x ≟ 3, A300)
E300 = CountIf(x ≟ 4, A300)
F300 = CountIf(x ≟ 5, A300)
G300 = CountIf(x ≟ 6, A300)
B300 = CountIf(x ≟ 1, A300)
H300: (B300 - 20)^(2) / 20 + (C300 - 20)^(2) / 20 + (D300 - 20)^(2) / 20 + (E300 - 20)^(2) / 20 + (F300 - 20)^(2) / 20 + (G300 - 20)^(2) / 20
I300 = Sum(abs(B300:G300 - 20))
J300: Max[B300:G300] - Min[B300:G300]
K300 = Max(abs(B300:G300 - 20))
L300: CountIf[x < 11, B300:G300] + CountIf[x > 29, B300:G300]
A301 = Sequence(Random[1, 6], k, 1, 120)
C301 = CountIf(x ≟ 2, A301)
D301 = CountIf(x ≟ 3, A301)
E301 = CountIf(x ≟ 4, A301)
F301 = CountIf(x ≟ 5, A301)
G301 = CountIf(x ≟ 6, A301)
B301 = CountIf(x ≟ 1, A301)
H301: (B301 - 20)^(2) / 20 + (C301 - 20)^(2) / 20 + (D301 - 20)^(2) / 20 + (E301 - 20)^(2) / 20 + (F301 - 20)^(2) / 20 + (G301 - 20)^(2) / 20
I301 = Sum(abs(B301:G301 - 20))
J301: Max[B301:G301] - Min[B301:G301]
K301 = Max(abs(B301:G301 - 20))
L301: CountIf[x < 11, B301:G301] + CountIf[x > 29, B301:G301]
A302 = Sequence(Random[1, 6], k, 1, 120)
C302 = CountIf(x ≟ 2, A302)
D302 = CountIf(x ≟ 3, A302)
E302 = CountIf(x ≟ 4, A302)
F302 = CountIf(x ≟ 5, A302)
G302 = CountIf(x ≟ 6, A302)
B302 = CountIf(x ≟ 1, A302)
H302: (B302 - 20)^(2) / 20 + (C302 - 20)^(2) / 20 + (D302 - 20)^(2) / 20 + (E302 - 20)^(2) / 20 + (F302 - 20)^(2) / 20 + (G302 - 20)^(2) / 20
I302 = Sum(abs(B302:G302 - 20))
J302: Max[B302:G302] - Min[B302:G302]
K302 = Max(abs(B302:G302 - 20))
L302: CountIf[x < 11, B302:G302] + CountIf[x > 29, B302:G302]
A303 = Sequence(Random[1, 6], k, 1, 120)
C303 = CountIf(x ≟ 2, A303)
D303 = CountIf(x ≟ 3, A303)
E303 = CountIf(x ≟ 4, A303)
F303 = CountIf(x ≟ 5, A303)
G303 = CountIf(x ≟ 6, A303)
B303 = CountIf(x ≟ 1, A303)
H303: (B303 - 20)^(2) / 20 + (C303 - 20)^(2) / 20 + (D303 - 20)^(2) / 20 + (E303 - 20)^(2) / 20 + (F303 - 20)^(2) / 20 + (G303 - 20)^(2) / 20
I303 = Sum(abs(B303:G303 - 20))
J303: Max[B303:G303] - Min[B303:G303]
K303 = Max(abs(B303:G303 - 20))
L303: CountIf[x < 11, B303:G303] + CountIf[x > 29, B303:G303]
A304 = Sequence(Random[1, 6], k, 1, 120)
C304 = CountIf(x ≟ 2, A304)
D304 = CountIf(x ≟ 3, A304)
E304 = CountIf(x ≟ 4, A304)
F304 = CountIf(x ≟ 5, A304)
G304 = CountIf(x ≟ 6, A304)
B304 = CountIf(x ≟ 1, A304)
H304: (B304 - 20)^(2) / 20 + (C304 - 20)^(2) / 20 + (D304 - 20)^(2) / 20 + (E304 - 20)^(2) / 20 + (F304 - 20)^(2) / 20 + (G304 - 20)^(2) / 20
I304 = Sum(abs(B304:G304 - 20))
J304: Max[B304:G304] - Min[B304:G304]
K304 = Max(abs(B304:G304 - 20))
L304: CountIf[x < 11, B304:G304] + CountIf[x > 29, B304:G304]
A305 = Sequence(Random[1, 6], k, 1, 120)
C305 = CountIf(x ≟ 2, A305)
D305 = CountIf(x ≟ 3, A305)
E305 = CountIf(x ≟ 4, A305)
F305 = CountIf(x ≟ 5, A305)
G305 = CountIf(x ≟ 6, A305)
B305 = CountIf(x ≟ 1, A305)
H305: (B305 - 20)^(2) / 20 + (C305 - 20)^(2) / 20 + (D305 - 20)^(2) / 20 + (E305 - 20)^(2) / 20 + (F305 - 20)^(2) / 20 + (G305 - 20)^(2) / 20
I305 = Sum(abs(B305:G305 - 20))
J305: Max[B305:G305] - Min[B305:G305]
K305 = Max(abs(B305:G305 - 20))
L305: CountIf[x < 11, B305:G305] + CountIf[x > 29, B305:G305]
A306 = Sequence(Random[1, 6], k, 1, 120)
C306 = CountIf(x ≟ 2, A306)
D306 = CountIf(x ≟ 3, A306)
E306 = CountIf(x ≟ 4, A306)
F306 = CountIf(x ≟ 5, A306)
G306 = CountIf(x ≟ 6, A306)
B306 = CountIf(x ≟ 1, A306)
H306: (B306 - 20)^(2) / 20 + (C306 - 20)^(2) / 20 + (D306 - 20)^(2) / 20 + (E306 - 20)^(2) / 20 + (F306 - 20)^(2) / 20 + (G306 - 20)^(2) / 20
I306 = Sum(abs(B306:G306 - 20))
J306: Max[B306:G306] - Min[B306:G306]
K306 = Max(abs(B306:G306 - 20))
L306: CountIf[x < 11, B306:G306] + CountIf[x > 29, B306:G306]
A307 = Sequence(Random[1, 6], k, 1, 120)
C307 = CountIf(x ≟ 2, A307)
D307 = CountIf(x ≟ 3, A307)
E307 = CountIf(x ≟ 4, A307)
F307 = CountIf(x ≟ 5, A307)
G307 = CountIf(x ≟ 6, A307)
B307 = CountIf(x ≟ 1, A307)
H307: (B307 - 20)^(2) / 20 + (C307 - 20)^(2) / 20 + (D307 - 20)^(2) / 20 + (E307 - 20)^(2) / 20 + (F307 - 20)^(2) / 20 + (G307 - 20)^(2) / 20
I307 = Sum(abs(B307:G307 - 20))
J307: Max[B307:G307] - Min[B307:G307]
K307 = Max(abs(B307:G307 - 20))
L307: CountIf[x < 11, B307:G307] + CountIf[x > 29, B307:G307]
A308 = Sequence(Random[1, 6], k, 1, 120)
C308 = CountIf(x ≟ 2, A308)
D308 = CountIf(x ≟ 3, A308)
E308 = CountIf(x ≟ 4, A308)
F308 = CountIf(x ≟ 5, A308)
G308 = CountIf(x ≟ 6, A308)
B308 = CountIf(x ≟ 1, A308)
H308: (B308 - 20)^(2) / 20 + (C308 - 20)^(2) / 20 + (D308 - 20)^(2) / 20 + (E308 - 20)^(2) / 20 + (F308 - 20)^(2) / 20 + (G308 - 20)^(2) / 20
I308 = Sum(abs(B308:G308 - 20))
J308: Max[B308:G308] - Min[B308:G308]
K308 = Max(abs(B308:G308 - 20))
L308: CountIf[x < 11, B308:G308] + CountIf[x > 29, B308:G308]
A309 = Sequence(Random[1, 6], k, 1, 120)
C309 = CountIf(x ≟ 2, A309)
D309 = CountIf(x ≟ 3, A309)
E309 = CountIf(x ≟ 4, A309)
F309 = CountIf(x ≟ 5, A309)
G309 = CountIf(x ≟ 6, A309)
B309 = CountIf(x ≟ 1, A309)
H309: (B309 - 20)^(2) / 20 + (C309 - 20)^(2) / 20 + (D309 - 20)^(2) / 20 + (E309 - 20)^(2) / 20 + (F309 - 20)^(2) / 20 + (G309 - 20)^(2) / 20
I309 = Sum(abs(B309:G309 - 20))
J309: Max[B309:G309] - Min[B309:G309]
K309 = Max(abs(B309:G309 - 20))
L309: CountIf[x < 11, B309:G309] + CountIf[x > 29, B309:G309]
A310 = Sequence(Random[1, 6], k, 1, 120)
C310 = CountIf(x ≟ 2, A310)
D310 = CountIf(x ≟ 3, A310)
E310 = CountIf(x ≟ 4, A310)
F310 = CountIf(x ≟ 5, A310)
G310 = CountIf(x ≟ 6, A310)
B310 = CountIf(x ≟ 1, A310)
H310: (B310 - 20)^(2) / 20 + (C310 - 20)^(2) / 20 + (D310 - 20)^(2) / 20 + (E310 - 20)^(2) / 20 + (F310 - 20)^(2) / 20 + (G310 - 20)^(2) / 20
I310 = Sum(abs(B310:G310 - 20))
J310: Max[B310:G310] - Min[B310:G310]
K310 = Max(abs(B310:G310 - 20))
L310: CountIf[x < 11, B310:G310] + CountIf[x > 29, B310:G310]
A311 = Sequence(Random[1, 6], k, 1, 120)
C311 = CountIf(x ≟ 2, A311)
D311 = CountIf(x ≟ 3, A311)
E311 = CountIf(x ≟ 4, A311)
F311 = CountIf(x ≟ 5, A311)
G311 = CountIf(x ≟ 6, A311)
B311 = CountIf(x ≟ 1, A311)
H311: (B311 - 20)^(2) / 20 + (C311 - 20)^(2) / 20 + (D311 - 20)^(2) / 20 + (E311 - 20)^(2) / 20 + (F311 - 20)^(2) / 20 + (G311 - 20)^(2) / 20
I311 = Sum(abs(B311:G311 - 20))
J311: Max[B311:G311] - Min[B311:G311]
K311 = Max(abs(B311:G311 - 20))
L311: CountIf[x < 11, B311:G311] + CountIf[x > 29, B311:G311]
A312 = Sequence(Random[1, 6], k, 1, 120)
C312 = CountIf(x ≟ 2, A312)
D312 = CountIf(x ≟ 3, A312)
E312 = CountIf(x ≟ 4, A312)
F312 = CountIf(x ≟ 5, A312)
G312 = CountIf(x ≟ 6, A312)
B312 = CountIf(x ≟ 1, A312)
H312: (B312 - 20)^(2) / 20 + (C312 - 20)^(2) / 20 + (D312 - 20)^(2) / 20 + (E312 - 20)^(2) / 20 + (F312 - 20)^(2) / 20 + (G312 - 20)^(2) / 20
I312 = Sum(abs(B312:G312 - 20))
J312: Max[B312:G312] - Min[B312:G312]
K312 = Max(abs(B312:G312 - 20))
L312: CountIf[x < 11, B312:G312] + CountIf[x > 29, B312:G312]
A313 = Sequence(Random[1, 6], k, 1, 120)
C313 = CountIf(x ≟ 2, A313)
D313 = CountIf(x ≟ 3, A313)
E313 = CountIf(x ≟ 4, A313)
F313 = CountIf(x ≟ 5, A313)
G313 = CountIf(x ≟ 6, A313)
B313 = CountIf(x ≟ 1, A313)
H313: (B313 - 20)^(2) / 20 + (C313 - 20)^(2) / 20 + (D313 - 20)^(2) / 20 + (E313 - 20)^(2) / 20 + (F313 - 20)^(2) / 20 + (G313 - 20)^(2) / 20
I313 = Sum(abs(B313:G313 - 20))
J313: Max[B313:G313] - Min[B313:G313]
K313 = Max(abs(B313:G313 - 20))
L313: CountIf[x < 11, B313:G313] + CountIf[x > 29, B313:G313]
A314 = Sequence(Random[1, 6], k, 1, 120)
C314 = CountIf(x ≟ 2, A314)
D314 = CountIf(x ≟ 3, A314)
E314 = CountIf(x ≟ 4, A314)
F314 = CountIf(x ≟ 5, A314)
G314 = CountIf(x ≟ 6, A314)
B314 = CountIf(x ≟ 1, A314)
H314: (B314 - 20)^(2) / 20 + (C314 - 20)^(2) / 20 + (D314 - 20)^(2) / 20 + (E314 - 20)^(2) / 20 + (F314 - 20)^(2) / 20 + (G314 - 20)^(2) / 20
I314 = Sum(abs(B314:G314 - 20))
J314: Max[B314:G314] - Min[B314:G314]
K314 = Max(abs(B314:G314 - 20))
L314: CountIf[x < 11, B314:G314] + CountIf[x > 29, B314:G314]
A315 = Sequence(Random[1, 6], k, 1, 120)
C315 = CountIf(x ≟ 2, A315)
D315 = CountIf(x ≟ 3, A315)
E315 = CountIf(x ≟ 4, A315)
F315 = CountIf(x ≟ 5, A315)
G315 = CountIf(x ≟ 6, A315)
B315 = CountIf(x ≟ 1, A315)
H315: (B315 - 20)^(2) / 20 + (C315 - 20)^(2) / 20 + (D315 - 20)^(2) / 20 + (E315 - 20)^(2) / 20 + (F315 - 20)^(2) / 20 + (G315 - 20)^(2) / 20
I315 = Sum(abs(B315:G315 - 20))
J315: Max[B315:G315] - Min[B315:G315]
K315 = Max(abs(B315:G315 - 20))
L315: CountIf[x < 11, B315:G315] + CountIf[x > 29, B315:G315]
A316 = Sequence(Random[1, 6], k, 1, 120)
C316 = CountIf(x ≟ 2, A316)
D316 = CountIf(x ≟ 3, A316)
E316 = CountIf(x ≟ 4, A316)
F316 = CountIf(x ≟ 5, A316)
G316 = CountIf(x ≟ 6, A316)
B316 = CountIf(x ≟ 1, A316)
H316: (B316 - 20)^(2) / 20 + (C316 - 20)^(2) / 20 + (D316 - 20)^(2) / 20 + (E316 - 20)^(2) / 20 + (F316 - 20)^(2) / 20 + (G316 - 20)^(2) / 20
I316 = Sum(abs(B316:G316 - 20))
J316: Max[B316:G316] - Min[B316:G316]
K316 = Max(abs(B316:G316 - 20))
L316: CountIf[x < 11, B316:G316] + CountIf[x > 29, B316:G316]
A317 = Sequence(Random[1, 6], k, 1, 120)
C317 = CountIf(x ≟ 2, A317)
D317 = CountIf(x ≟ 3, A317)
E317 = CountIf(x ≟ 4, A317)
F317 = CountIf(x ≟ 5, A317)
G317 = CountIf(x ≟ 6, A317)
B317 = CountIf(x ≟ 1, A317)
H317: (B317 - 20)^(2) / 20 + (C317 - 20)^(2) / 20 + (D317 - 20)^(2) / 20 + (E317 - 20)^(2) / 20 + (F317 - 20)^(2) / 20 + (G317 - 20)^(2) / 20
I317 = Sum(abs(B317:G317 - 20))
J317: Max[B317:G317] - Min[B317:G317]
K317 = Max(abs(B317:G317 - 20))
L317: CountIf[x < 11, B317:G317] + CountIf[x > 29, B317:G317]
A318 = Sequence(Random[1, 6], k, 1, 120)
C318 = CountIf(x ≟ 2, A318)
D318 = CountIf(x ≟ 3, A318)
E318 = CountIf(x ≟ 4, A318)
F318 = CountIf(x ≟ 5, A318)
G318 = CountIf(x ≟ 6, A318)
B318 = CountIf(x ≟ 1, A318)
H318: (B318 - 20)^(2) / 20 + (C318 - 20)^(2) / 20 + (D318 - 20)^(2) / 20 + (E318 - 20)^(2) / 20 + (F318 - 20)^(2) / 20 + (G318 - 20)^(2) / 20
I318 = Sum(abs(B318:G318 - 20))
J318: Max[B318:G318] - Min[B318:G318]
K318 = Max(abs(B318:G318 - 20))
L318: CountIf[x < 11, B318:G318] + CountIf[x > 29, B318:G318]
A319 = Sequence(Random[1, 6], k, 1, 120)
C319 = CountIf(x ≟ 2, A319)
D319 = CountIf(x ≟ 3, A319)
E319 = CountIf(x ≟ 4, A319)
F319 = CountIf(x ≟ 5, A319)
G319 = CountIf(x ≟ 6, A319)
B319 = CountIf(x ≟ 1, A319)
H319: (B319 - 20)^(2) / 20 + (C319 - 20)^(2) / 20 + (D319 - 20)^(2) / 20 + (E319 - 20)^(2) / 20 + (F319 - 20)^(2) / 20 + (G319 - 20)^(2) / 20
I319 = Sum(abs(B319:G319 - 20))
J319: Max[B319:G319] - Min[B319:G319]
K319 = Max(abs(B319:G319 - 20))
L319: CountIf[x < 11, B319:G319] + CountIf[x > 29, B319:G319]
A320 = Sequence(Random[1, 6], k, 1, 120)
C320 = CountIf(x ≟ 2, A320)
D320 = CountIf(x ≟ 3, A320)
E320 = CountIf(x ≟ 4, A320)
F320 = CountIf(x ≟ 5, A320)
G320 = CountIf(x ≟ 6, A320)
B320 = CountIf(x ≟ 1, A320)
H320: (B320 - 20)^(2) / 20 + (C320 - 20)^(2) / 20 + (D320 - 20)^(2) / 20 + (E320 - 20)^(2) / 20 + (F320 - 20)^(2) / 20 + (G320 - 20)^(2) / 20
I320 = Sum(abs(B320:G320 - 20))
J320: Max[B320:G320] - Min[B320:G320]
K320 = Max(abs(B320:G320 - 20))
L320: CountIf[x < 11, B320:G320] + CountIf[x > 29, B320:G320]
A321 = Sequence(Random[1, 6], k, 1, 120)
C321 = CountIf(x ≟ 2, A321)
D321 = CountIf(x ≟ 3, A321)
E321 = CountIf(x ≟ 4, A321)
F321 = CountIf(x ≟ 5, A321)
G321 = CountIf(x ≟ 6, A321)
B321 = CountIf(x ≟ 1, A321)
H321: (B321 - 20)^(2) / 20 + (C321 - 20)^(2) / 20 + (D321 - 20)^(2) / 20 + (E321 - 20)^(2) / 20 + (F321 - 20)^(2) / 20 + (G321 - 20)^(2) / 20
I321 = Sum(abs(B321:G321 - 20))
J321: Max[B321:G321] - Min[B321:G321]
K321 = Max(abs(B321:G321 - 20))
L321: CountIf[x < 11, B321:G321] + CountIf[x > 29, B321:G321]
A322 = Sequence(Random[1, 6], k, 1, 120)
C322 = CountIf(x ≟ 2, A322)
D322 = CountIf(x ≟ 3, A322)
E322 = CountIf(x ≟ 4, A322)
F322 = CountIf(x ≟ 5, A322)
G322 = CountIf(x ≟ 6, A322)
B322 = CountIf(x ≟ 1, A322)
H322: (B322 - 20)^(2) / 20 + (C322 - 20)^(2) / 20 + (D322 - 20)^(2) / 20 + (E322 - 20)^(2) / 20 + (F322 - 20)^(2) / 20 + (G322 - 20)^(2) / 20
I322 = Sum(abs(B322:G322 - 20))
J322: Max[B322:G322] - Min[B322:G322]
K322 = Max(abs(B322:G322 - 20))
L322: CountIf[x < 11, B322:G322] + CountIf[x > 29, B322:G322]
A323 = Sequence(Random[1, 6], k, 1, 120)
C323 = CountIf(x ≟ 2, A323)
D323 = CountIf(x ≟ 3, A323)
E323 = CountIf(x ≟ 4, A323)
F323 = CountIf(x ≟ 5, A323)
G323 = CountIf(x ≟ 6, A323)
B323 = CountIf(x ≟ 1, A323)
H323: (B323 - 20)^(2) / 20 + (C323 - 20)^(2) / 20 + (D323 - 20)^(2) / 20 + (E323 - 20)^(2) / 20 + (F323 - 20)^(2) / 20 + (G323 - 20)^(2) / 20
I323 = Sum(abs(B323:G323 - 20))
J323: Max[B323:G323] - Min[B323:G323]
K323 = Max(abs(B323:G323 - 20))
L323: CountIf[x < 11, B323:G323] + CountIf[x > 29, B323:G323]
A324 = Sequence(Random[1, 6], k, 1, 120)
C324 = CountIf(x ≟ 2, A324)
D324 = CountIf(x ≟ 3, A324)
E324 = CountIf(x ≟ 4, A324)
F324 = CountIf(x ≟ 5, A324)
G324 = CountIf(x ≟ 6, A324)
B324 = CountIf(x ≟ 1, A324)
H324: (B324 - 20)^(2) / 20 + (C324 - 20)^(2) / 20 + (D324 - 20)^(2) / 20 + (E324 - 20)^(2) / 20 + (F324 - 20)^(2) / 20 + (G324 - 20)^(2) / 20
I324 = Sum(abs(B324:G324 - 20))
J324: Max[B324:G324] - Min[B324:G324]
K324 = Max(abs(B324:G324 - 20))
L324: CountIf[x < 11, B324:G324] + CountIf[x > 29, B324:G324]
A325 = Sequence(Random[1, 6], k, 1, 120)
C325 = CountIf(x ≟ 2, A325)
D325 = CountIf(x ≟ 3, A325)
E325 = CountIf(x ≟ 4, A325)
F325 = CountIf(x ≟ 5, A325)
G325 = CountIf(x ≟ 6, A325)
B325 = CountIf(x ≟ 1, A325)
H325: (B325 - 20)^(2) / 20 + (C325 - 20)^(2) / 20 + (D325 - 20)^(2) / 20 + (E325 - 20)^(2) / 20 + (F325 - 20)^(2) / 20 + (G325 - 20)^(2) / 20
I325 = Sum(abs(B325:G325 - 20))
J325: Max[B325:G325] - Min[B325:G325]
K325 = Max(abs(B325:G325 - 20))
L325: CountIf[x < 11, B325:G325] + CountIf[x > 29, B325:G325]
A326 = Sequence(Random[1, 6], k, 1, 120)
C326 = CountIf(x ≟ 2, A326)
D326 = CountIf(x ≟ 3, A326)
E326 = CountIf(x ≟ 4, A326)
F326 = CountIf(x ≟ 5, A326)
G326 = CountIf(x ≟ 6, A326)
B326 = CountIf(x ≟ 1, A326)
H326: (B326 - 20)^(2) / 20 + (C326 - 20)^(2) / 20 + (D326 - 20)^(2) / 20 + (E326 - 20)^(2) / 20 + (F326 - 20)^(2) / 20 + (G326 - 20)^(2) / 20
I326 = Sum(abs(B326:G326 - 20))
J326: Max[B326:G326] - Min[B326:G326]
K326 = Max(abs(B326:G326 - 20))
L326: CountIf[x < 11, B326:G326] + CountIf[x > 29, B326:G326]
A327 = Sequence(Random[1, 6], k, 1, 120)
C327 = CountIf(x ≟ 2, A327)
D327 = CountIf(x ≟ 3, A327)
E327 = CountIf(x ≟ 4, A327)
F327 = CountIf(x ≟ 5, A327)
G327 = CountIf(x ≟ 6, A327)
B327 = CountIf(x ≟ 1, A327)
H327: (B327 - 20)^(2) / 20 + (C327 - 20)^(2) / 20 + (D327 - 20)^(2) / 20 + (E327 - 20)^(2) / 20 + (F327 - 20)^(2) / 20 + (G327 - 20)^(2) / 20
I327 = Sum(abs(B327:G327 - 20))
J327: Max[B327:G327] - Min[B327:G327]
K327 = Max(abs(B327:G327 - 20))
L327: CountIf[x < 11, B327:G327] + CountIf[x > 29, B327:G327]
A328 = Sequence(Random[1, 6], k, 1, 120)
C328 = CountIf(x ≟ 2, A328)
D328 = CountIf(x ≟ 3, A328)
E328 = CountIf(x ≟ 4, A328)
F328 = CountIf(x ≟ 5, A328)
G328 = CountIf(x ≟ 6, A328)
B328 = CountIf(x ≟ 1, A328)
H328: (B328 - 20)^(2) / 20 + (C328 - 20)^(2) / 20 + (D328 - 20)^(2) / 20 + (E328 - 20)^(2) / 20 + (F328 - 20)^(2) / 20 + (G328 - 20)^(2) / 20
I328 = Sum(abs(B328:G328 - 20))
J328: Max[B328:G328] - Min[B328:G328]
K328 = Max(abs(B328:G328 - 20))
L328: CountIf[x < 11, B328:G328] + CountIf[x > 29, B328:G328]
A329 = Sequence(Random[1, 6], k, 1, 120)
C329 = CountIf(x ≟ 2, A329)
D329 = CountIf(x ≟ 3, A329)
E329 = CountIf(x ≟ 4, A329)
F329 = CountIf(x ≟ 5, A329)
G329 = CountIf(x ≟ 6, A329)
B329 = CountIf(x ≟ 1, A329)
H329: (B329 - 20)^(2) / 20 + (C329 - 20)^(2) / 20 + (D329 - 20)^(2) / 20 + (E329 - 20)^(2) / 20 + (F329 - 20)^(2) / 20 + (G329 - 20)^(2) / 20
I329 = Sum(abs(B329:G329 - 20))
J329: Max[B329:G329] - Min[B329:G329]
K329 = Max(abs(B329:G329 - 20))
L329: CountIf[x < 11, B329:G329] + CountIf[x > 29, B329:G329]
A330 = Sequence(Random[1, 6], k, 1, 120)
C330 = CountIf(x ≟ 2, A330)
D330 = CountIf(x ≟ 3, A330)
E330 = CountIf(x ≟ 4, A330)
F330 = CountIf(x ≟ 5, A330)
G330 = CountIf(x ≟ 6, A330)
B330 = CountIf(x ≟ 1, A330)
H330: (B330 - 20)^(2) / 20 + (C330 - 20)^(2) / 20 + (D330 - 20)^(2) / 20 + (E330 - 20)^(2) / 20 + (F330 - 20)^(2) / 20 + (G330 - 20)^(2) / 20
I330 = Sum(abs(B330:G330 - 20))
J330: Max[B330:G330] - Min[B330:G330]
K330 = Max(abs(B330:G330 - 20))
L330: CountIf[x < 11, B330:G330] + CountIf[x > 29, B330:G330]
A331 = Sequence(Random[1, 6], k, 1, 120)
C331 = CountIf(x ≟ 2, A331)
D331 = CountIf(x ≟ 3, A331)
E331 = CountIf(x ≟ 4, A331)
F331 = CountIf(x ≟ 5, A331)
G331 = CountIf(x ≟ 6, A331)
B331 = CountIf(x ≟ 1, A331)
H331: (B331 - 20)^(2) / 20 + (C331 - 20)^(2) / 20 + (D331 - 20)^(2) / 20 + (E331 - 20)^(2) / 20 + (F331 - 20)^(2) / 20 + (G331 - 20)^(2) / 20
I331 = Sum(abs(B331:G331 - 20))
J331: Max[B331:G331] - Min[B331:G331]
K331 = Max(abs(B331:G331 - 20))
L331: CountIf[x < 11, B331:G331] + CountIf[x > 29, B331:G331]
A332 = Sequence(Random[1, 6], k, 1, 120)
C332 = CountIf(x ≟ 2, A332)
D332 = CountIf(x ≟ 3, A332)
E332 = CountIf(x ≟ 4, A332)
F332 = CountIf(x ≟ 5, A332)
G332 = CountIf(x ≟ 6, A332)
B332 = CountIf(x ≟ 1, A332)
H332: (B332 - 20)^(2) / 20 + (C332 - 20)^(2) / 20 + (D332 - 20)^(2) / 20 + (E332 - 20)^(2) / 20 + (F332 - 20)^(2) / 20 + (G332 - 20)^(2) / 20
I332 = Sum(abs(B332:G332 - 20))
J332: Max[B332:G332] - Min[B332:G332]
K332 = Max(abs(B332:G332 - 20))
L332: CountIf[x < 11, B332:G332] + CountIf[x > 29, B332:G332]
A333 = Sequence(Random[1, 6], k, 1, 120)
C333 = CountIf(x ≟ 2, A333)
D333 = CountIf(x ≟ 3, A333)
E333 = CountIf(x ≟ 4, A333)
F333 = CountIf(x ≟ 5, A333)
G333 = CountIf(x ≟ 6, A333)
B333 = CountIf(x ≟ 1, A333)
H333: (B333 - 20)^(2) / 20 + (C333 - 20)^(2) / 20 + (D333 - 20)^(2) / 20 + (E333 - 20)^(2) / 20 + (F333 - 20)^(2) / 20 + (G333 - 20)^(2) / 20
I333 = Sum(abs(B333:G333 - 20))
J333: Max[B333:G333] - Min[B333:G333]
K333 = Max(abs(B333:G333 - 20))
L333: CountIf[x < 11, B333:G333] + CountIf[x > 29, B333:G333]
A334 = Sequence(Random[1, 6], k, 1, 120)
C334 = CountIf(x ≟ 2, A334)
D334 = CountIf(x ≟ 3, A334)
E334 = CountIf(x ≟ 4, A334)
F334 = CountIf(x ≟ 5, A334)
G334 = CountIf(x ≟ 6, A334)
B334 = CountIf(x ≟ 1, A334)
H334: (B334 - 20)^(2) / 20 + (C334 - 20)^(2) / 20 + (D334 - 20)^(2) / 20 + (E334 - 20)^(2) / 20 + (F334 - 20)^(2) / 20 + (G334 - 20)^(2) / 20
I334 = Sum(abs(B334:G334 - 20))
J334: Max[B334:G334] - Min[B334:G334]
K334 = Max(abs(B334:G334 - 20))
L334: CountIf[x < 11, B334:G334] + CountIf[x > 29, B334:G334]
A335 = Sequence(Random[1, 6], k, 1, 120)
C335 = CountIf(x ≟ 2, A335)
D335 = CountIf(x ≟ 3, A335)
E335 = CountIf(x ≟ 4, A335)
F335 = CountIf(x ≟ 5, A335)
G335 = CountIf(x ≟ 6, A335)
B335 = CountIf(x ≟ 1, A335)
H335: (B335 - 20)^(2) / 20 + (C335 - 20)^(2) / 20 + (D335 - 20)^(2) / 20 + (E335 - 20)^(2) / 20 + (F335 - 20)^(2) / 20 + (G335 - 20)^(2) / 20
I335 = Sum(abs(B335:G335 - 20))
J335: Max[B335:G335] - Min[B335:G335]
K335 = Max(abs(B335:G335 - 20))
L335: CountIf[x < 11, B335:G335] + CountIf[x > 29, B335:G335]
A336 = Sequence(Random[1, 6], k, 1, 120)
C336 = CountIf(x ≟ 2, A336)
D336 = CountIf(x ≟ 3, A336)
E336 = CountIf(x ≟ 4, A336)
F336 = CountIf(x ≟ 5, A336)
G336 = CountIf(x ≟ 6, A336)
B336 = CountIf(x ≟ 1, A336)
H336: (B336 - 20)^(2) / 20 + (C336 - 20)^(2) / 20 + (D336 - 20)^(2) / 20 + (E336 - 20)^(2) / 20 + (F336 - 20)^(2) / 20 + (G336 - 20)^(2) / 20
I336 = Sum(abs(B336:G336 - 20))
J336: Max[B336:G336] - Min[B336:G336]
K336 = Max(abs(B336:G336 - 20))
L336: CountIf[x < 11, B336:G336] + CountIf[x > 29, B336:G336]
A337 = Sequence(Random[1, 6], k, 1, 120)
C337 = CountIf(x ≟ 2, A337)
D337 = CountIf(x ≟ 3, A337)
E337 = CountIf(x ≟ 4, A337)
F337 = CountIf(x ≟ 5, A337)
G337 = CountIf(x ≟ 6, A337)
B337 = CountIf(x ≟ 1, A337)
H337: (B337 - 20)^(2) / 20 + (C337 - 20)^(2) / 20 + (D337 - 20)^(2) / 20 + (E337 - 20)^(2) / 20 + (F337 - 20)^(2) / 20 + (G337 - 20)^(2) / 20
I337 = Sum(abs(B337:G337 - 20))
J337: Max[B337:G337] - Min[B337:G337]
K337 = Max(abs(B337:G337 - 20))
L337: CountIf[x < 11, B337:G337] + CountIf[x > 29, B337:G337]
A338 = Sequence(Random[1, 6], k, 1, 120)
C338 = CountIf(x ≟ 2, A338)
D338 = CountIf(x ≟ 3, A338)
E338 = CountIf(x ≟ 4, A338)
F338 = CountIf(x ≟ 5, A338)
G338 = CountIf(x ≟ 6, A338)
B338 = CountIf(x ≟ 1, A338)
H338: (B338 - 20)^(2) / 20 + (C338 - 20)^(2) / 20 + (D338 - 20)^(2) / 20 + (E338 - 20)^(2) / 20 + (F338 - 20)^(2) / 20 + (G338 - 20)^(2) / 20
I338 = Sum(abs(B338:G338 - 20))
J338: Max[B338:G338] - Min[B338:G338]
K338 = Max(abs(B338:G338 - 20))
L338: CountIf[x < 11, B338:G338] + CountIf[x > 29, B338:G338]
A339 = Sequence(Random[1, 6], k, 1, 120)
C339 = CountIf(x ≟ 2, A339)
D339 = CountIf(x ≟ 3, A339)
E339 = CountIf(x ≟ 4, A339)
F339 = CountIf(x ≟ 5, A339)
G339 = CountIf(x ≟ 6, A339)
B339 = CountIf(x ≟ 1, A339)
H339: (B339 - 20)^(2) / 20 + (C339 - 20)^(2) / 20 + (D339 - 20)^(2) / 20 + (E339 - 20)^(2) / 20 + (F339 - 20)^(2) / 20 + (G339 - 20)^(2) / 20
I339 = Sum(abs(B339:G339 - 20))
J339: Max[B339:G339] - Min[B339:G339]
K339 = Max(abs(B339:G339 - 20))
L339: CountIf[x < 11, B339:G339] + CountIf[x > 29, B339:G339]
A340 = Sequence(Random[1, 6], k, 1, 120)
C340 = CountIf(x ≟ 2, A340)
D340 = CountIf(x ≟ 3, A340)
E340 = CountIf(x ≟ 4, A340)
F340 = CountIf(x ≟ 5, A340)
G340 = CountIf(x ≟ 6, A340)
B340 = CountIf(x ≟ 1, A340)
H340: (B340 - 20)^(2) / 20 + (C340 - 20)^(2) / 20 + (D340 - 20)^(2) / 20 + (E340 - 20)^(2) / 20 + (F340 - 20)^(2) / 20 + (G340 - 20)^(2) / 20
I340 = Sum(abs(B340:G340 - 20))
J340: Max[B340:G340] - Min[B340:G340]
K340 = Max(abs(B340:G340 - 20))
L340: CountIf[x < 11, B340:G340] + CountIf[x > 29, B340:G340]
A341 = Sequence(Random[1, 6], k, 1, 120)
C341 = CountIf(x ≟ 2, A341)
D341 = CountIf(x ≟ 3, A341)
E341 = CountIf(x ≟ 4, A341)
F341 = CountIf(x ≟ 5, A341)
G341 = CountIf(x ≟ 6, A341)
B341 = CountIf(x ≟ 1, A341)
H341: (B341 - 20)^(2) / 20 + (C341 - 20)^(2) / 20 + (D341 - 20)^(2) / 20 + (E341 - 20)^(2) / 20 + (F341 - 20)^(2) / 20 + (G341 - 20)^(2) / 20
I341 = Sum(abs(B341:G341 - 20))
J341: Max[B341:G341] - Min[B341:G341]
K341 = Max(abs(B341:G341 - 20))
L341: CountIf[x < 11, B341:G341] + CountIf[x > 29, B341:G341]
A342 = Sequence(Random[1, 6], k, 1, 120)
C342 = CountIf(x ≟ 2, A342)
D342 = CountIf(x ≟ 3, A342)
E342 = CountIf(x ≟ 4, A342)
F342 = CountIf(x ≟ 5, A342)
G342 = CountIf(x ≟ 6, A342)
B342 = CountIf(x ≟ 1, A342)
H342: (B342 - 20)^(2) / 20 + (C342 - 20)^(2) / 20 + (D342 - 20)^(2) / 20 + (E342 - 20)^(2) / 20 + (F342 - 20)^(2) / 20 + (G342 - 20)^(2) / 20
I342 = Sum(abs(B342:G342 - 20))
J342: Max[B342:G342] - Min[B342:G342]
K342 = Max(abs(B342:G342 - 20))
L342: CountIf[x < 11, B342:G342] + CountIf[x > 29, B342:G342]
A343 = Sequence(Random[1, 6], k, 1, 120)
C343 = CountIf(x ≟ 2, A343)
D343 = CountIf(x ≟ 3, A343)
E343 = CountIf(x ≟ 4, A343)
F343 = CountIf(x ≟ 5, A343)
G343 = CountIf(x ≟ 6, A343)
B343 = CountIf(x ≟ 1, A343)
H343: (B343 - 20)^(2) / 20 + (C343 - 20)^(2) / 20 + (D343 - 20)^(2) / 20 + (E343 - 20)^(2) / 20 + (F343 - 20)^(2) / 20 + (G343 - 20)^(2) / 20
I343 = Sum(abs(B343:G343 - 20))
J343: Max[B343:G343] - Min[B343:G343]
K343 = Max(abs(B343:G343 - 20))
L343: CountIf[x < 11, B343:G343] + CountIf[x > 29, B343:G343]
A344 = Sequence(Random[1, 6], k, 1, 120)
C344 = CountIf(x ≟ 2, A344)
D344 = CountIf(x ≟ 3, A344)
E344 = CountIf(x ≟ 4, A344)
F344 = CountIf(x ≟ 5, A344)
G344 = CountIf(x ≟ 6, A344)
B344 = CountIf(x ≟ 1, A344)
H344: (B344 - 20)^(2) / 20 + (C344 - 20)^(2) / 20 + (D344 - 20)^(2) / 20 + (E344 - 20)^(2) / 20 + (F344 - 20)^(2) / 20 + (G344 - 20)^(2) / 20
I344 = Sum(abs(B344:G344 - 20))
J344: Max[B344:G344] - Min[B344:G344]
K344 = Max(abs(B344:G344 - 20))
L344: CountIf[x < 11, B344:G344] + CountIf[x > 29, B344:G344]
A345 = Sequence(Random[1, 6], k, 1, 120)
C345 = CountIf(x ≟ 2, A345)
D345 = CountIf(x ≟ 3, A345)
E345 = CountIf(x ≟ 4, A345)
F345 = CountIf(x ≟ 5, A345)
G345 = CountIf(x ≟ 6, A345)
B345 = CountIf(x ≟ 1, A345)
H345: (B345 - 20)^(2) / 20 + (C345 - 20)^(2) / 20 + (D345 - 20)^(2) / 20 + (E345 - 20)^(2) / 20 + (F345 - 20)^(2) / 20 + (G345 - 20)^(2) / 20
I345 = Sum(abs(B345:G345 - 20))
J345: Max[B345:G345] - Min[B345:G345]
K345 = Max(abs(B345:G345 - 20))
L345: CountIf[x < 11, B345:G345] + CountIf[x > 29, B345:G345]
A346 = Sequence(Random[1, 6], k, 1, 120)
C346 = CountIf(x ≟ 2, A346)
D346 = CountIf(x ≟ 3, A346)
E346 = CountIf(x ≟ 4, A346)
F346 = CountIf(x ≟ 5, A346)
G346 = CountIf(x ≟ 6, A346)
B346 = CountIf(x ≟ 1, A346)
H346: (B346 - 20)^(2) / 20 + (C346 - 20)^(2) / 20 + (D346 - 20)^(2) / 20 + (E346 - 20)^(2) / 20 + (F346 - 20)^(2) / 20 + (G346 - 20)^(2) / 20
I346 = Sum(abs(B346:G346 - 20))
J346: Max[B346:G346] - Min[B346:G346]
K346 = Max(abs(B346:G346 - 20))
L346: CountIf[x < 11, B346:G346] + CountIf[x > 29, B346:G346]
A347 = Sequence(Random[1, 6], k, 1, 120)
C347 = CountIf(x ≟ 2, A347)
D347 = CountIf(x ≟ 3, A347)
E347 = CountIf(x ≟ 4, A347)
F347 = CountIf(x ≟ 5, A347)
G347 = CountIf(x ≟ 6, A347)
B347 = CountIf(x ≟ 1, A347)
H347: (B347 - 20)^(2) / 20 + (C347 - 20)^(2) / 20 + (D347 - 20)^(2) / 20 + (E347 - 20)^(2) / 20 + (F347 - 20)^(2) / 20 + (G347 - 20)^(2) / 20
I347 = Sum(abs(B347:G347 - 20))
J347: Max[B347:G347] - Min[B347:G347]
K347 = Max(abs(B347:G347 - 20))
L347: CountIf[x < 11, B347:G347] + CountIf[x > 29, B347:G347]
A348 = Sequence(Random[1, 6], k, 1, 120)
C348 = CountIf(x ≟ 2, A348)
D348 = CountIf(x ≟ 3, A348)
E348 = CountIf(x ≟ 4, A348)
F348 = CountIf(x ≟ 5, A348)
G348 = CountIf(x ≟ 6, A348)
B348 = CountIf(x ≟ 1, A348)
H348: (B348 - 20)^(2) / 20 + (C348 - 20)^(2) / 20 + (D348 - 20)^(2) / 20 + (E348 - 20)^(2) / 20 + (F348 - 20)^(2) / 20 + (G348 - 20)^(2) / 20
I348 = Sum(abs(B348:G348 - 20))
J348: Max[B348:G348] - Min[B348:G348]
K348 = Max(abs(B348:G348 - 20))
L348: CountIf[x < 11, B348:G348] + CountIf[x > 29, B348:G348]
A349 = Sequence(Random[1, 6], k, 1, 120)
C349 = CountIf(x ≟ 2, A349)
D349 = CountIf(x ≟ 3, A349)
E349 = CountIf(x ≟ 4, A349)
F349 = CountIf(x ≟ 5, A349)
G349 = CountIf(x ≟ 6, A349)
B349 = CountIf(x ≟ 1, A349)
H349: (B349 - 20)^(2) / 20 + (C349 - 20)^(2) / 20 + (D349 - 20)^(2) / 20 + (E349 - 20)^(2) / 20 + (F349 - 20)^(2) / 20 + (G349 - 20)^(2) / 20
I349 = Sum(abs(B349:G349 - 20))
J349: Max[B349:G349] - Min[B349:G349]
K349 = Max(abs(B349:G349 - 20))
L349: CountIf[x < 11, B349:G349] + CountIf[x > 29, B349:G349]
A350 = Sequence(Random[1, 6], k, 1, 120)
C350 = CountIf(x ≟ 2, A350)
D350 = CountIf(x ≟ 3, A350)
E350 = CountIf(x ≟ 4, A350)
F350 = CountIf(x ≟ 5, A350)
G350 = CountIf(x ≟ 6, A350)
B350 = CountIf(x ≟ 1, A350)
H350: (B350 - 20)^(2) / 20 + (C350 - 20)^(2) / 20 + (D350 - 20)^(2) / 20 + (E350 - 20)^(2) / 20 + (F350 - 20)^(2) / 20 + (G350 - 20)^(2) / 20
I350 = Sum(abs(B350:G350 - 20))
J350: Max[B350:G350] - Min[B350:G350]
K350 = Max(abs(B350:G350 - 20))
L350: CountIf[x < 11, B350:G350] + CountIf[x > 29, B350:G350]
A351 = Sequence(Random[1, 6], k, 1, 120)
C351 = CountIf(x ≟ 2, A351)
D351 = CountIf(x ≟ 3, A351)
E351 = CountIf(x ≟ 4, A351)
F351 = CountIf(x ≟ 5, A351)
G351 = CountIf(x ≟ 6, A351)
B351 = CountIf(x ≟ 1, A351)
H351: (B351 - 20)^(2) / 20 + (C351 - 20)^(2) / 20 + (D351 - 20)^(2) / 20 + (E351 - 20)^(2) / 20 + (F351 - 20)^(2) / 20 + (G351 - 20)^(2) / 20
I351 = Sum(abs(B351:G351 - 20))
J351: Max[B351:G351] - Min[B351:G351]
K351 = Max(abs(B351:G351 - 20))
L351: CountIf[x < 11, B351:G351] + CountIf[x > 29, B351:G351]
A352 = Sequence(Random[1, 6], k, 1, 120)
C352 = CountIf(x ≟ 2, A352)
D352 = CountIf(x ≟ 3, A352)
E352 = CountIf(x ≟ 4, A352)
F352 = CountIf(x ≟ 5, A352)
G352 = CountIf(x ≟ 6, A352)
B352 = CountIf(x ≟ 1, A352)
H352: (B352 - 20)^(2) / 20 + (C352 - 20)^(2) / 20 + (D352 - 20)^(2) / 20 + (E352 - 20)^(2) / 20 + (F352 - 20)^(2) / 20 + (G352 - 20)^(2) / 20
I352 = Sum(abs(B352:G352 - 20))
J352: Max[B352:G352] - Min[B352:G352]
K352 = Max(abs(B352:G352 - 20))
L352: CountIf[x < 11, B352:G352] + CountIf[x > 29, B352:G352]
A353 = Sequence(Random[1, 6], k, 1, 120)
C353 = CountIf(x ≟ 2, A353)
D353 = CountIf(x ≟ 3, A353)
E353 = CountIf(x ≟ 4, A353)
F353 = CountIf(x ≟ 5, A353)
G353 = CountIf(x ≟ 6, A353)
B353 = CountIf(x ≟ 1, A353)
H353: (B353 - 20)^(2) / 20 + (C353 - 20)^(2) / 20 + (D353 - 20)^(2) / 20 + (E353 - 20)^(2) / 20 + (F353 - 20)^(2) / 20 + (G353 - 20)^(2) / 20
I353 = Sum(abs(B353:G353 - 20))
J353: Max[B353:G353] - Min[B353:G353]
K353 = Max(abs(B353:G353 - 20))
L353: CountIf[x < 11, B353:G353] + CountIf[x > 29, B353:G353]
A354 = Sequence(Random[1, 6], k, 1, 120)
C354 = CountIf(x ≟ 2, A354)
D354 = CountIf(x ≟ 3, A354)
E354 = CountIf(x ≟ 4, A354)
F354 = CountIf(x ≟ 5, A354)
G354 = CountIf(x ≟ 6, A354)
B354 = CountIf(x ≟ 1, A354)
H354: (B354 - 20)^(2) / 20 + (C354 - 20)^(2) / 20 + (D354 - 20)^(2) / 20 + (E354 - 20)^(2) / 20 + (F354 - 20)^(2) / 20 + (G354 - 20)^(2) / 20
I354 = Sum(abs(B354:G354 - 20))
J354: Max[B354:G354] - Min[B354:G354]
K354 = Max(abs(B354:G354 - 20))
L354: CountIf[x < 11, B354:G354] + CountIf[x > 29, B354:G354]
A355 = Sequence(Random[1, 6], k, 1, 120)
C355 = CountIf(x ≟ 2, A355)
D355 = CountIf(x ≟ 3, A355)
E355 = CountIf(x ≟ 4, A355)
F355 = CountIf(x ≟ 5, A355)
G355 = CountIf(x ≟ 6, A355)
B355 = CountIf(x ≟ 1, A355)
H355: (B355 - 20)^(2) / 20 + (C355 - 20)^(2) / 20 + (D355 - 20)^(2) / 20 + (E355 - 20)^(2) / 20 + (F355 - 20)^(2) / 20 + (G355 - 20)^(2) / 20
I355 = Sum(abs(B355:G355 - 20))
J355: Max[B355:G355] - Min[B355:G355]
K355 = Max(abs(B355:G355 - 20))
L355: CountIf[x < 11, B355:G355] + CountIf[x > 29, B355:G355]
A356 = Sequence(Random[1, 6], k, 1, 120)
C356 = CountIf(x ≟ 2, A356)
D356 = CountIf(x ≟ 3, A356)
E356 = CountIf(x ≟ 4, A356)
F356 = CountIf(x ≟ 5, A356)
G356 = CountIf(x ≟ 6, A356)
B356 = CountIf(x ≟ 1, A356)
H356: (B356 - 20)^(2) / 20 + (C356 - 20)^(2) / 20 + (D356 - 20)^(2) / 20 + (E356 - 20)^(2) / 20 + (F356 - 20)^(2) / 20 + (G356 - 20)^(2) / 20
I356 = Sum(abs(B356:G356 - 20))
J356: Max[B356:G356] - Min[B356:G356]
K356 = Max(abs(B356:G356 - 20))
L356: CountIf[x < 11, B356:G356] + CountIf[x > 29, B356:G356]
A357 = Sequence(Random[1, 6], k, 1, 120)
C357 = CountIf(x ≟ 2, A357)
D357 = CountIf(x ≟ 3, A357)
E357 = CountIf(x ≟ 4, A357)
F357 = CountIf(x ≟ 5, A357)
G357 = CountIf(x ≟ 6, A357)
B357 = CountIf(x ≟ 1, A357)
H357: (B357 - 20)^(2) / 20 + (C357 - 20)^(2) / 20 + (D357 - 20)^(2) / 20 + (E357 - 20)^(2) / 20 + (F357 - 20)^(2) / 20 + (G357 - 20)^(2) / 20
I357 = Sum(abs(B357:G357 - 20))
J357: Max[B357:G357] - Min[B357:G357]
K357 = Max(abs(B357:G357 - 20))
L357: CountIf[x < 11, B357:G357] + CountIf[x > 29, B357:G357]
A358 = Sequence(Random[1, 6], k, 1, 120)
C358 = CountIf(x ≟ 2, A358)
D358 = CountIf(x ≟ 3, A358)
E358 = CountIf(x ≟ 4, A358)
F358 = CountIf(x ≟ 5, A358)
G358 = CountIf(x ≟ 6, A358)
B358 = CountIf(x ≟ 1, A358)
H358: (B358 - 20)^(2) / 20 + (C358 - 20)^(2) / 20 + (D358 - 20)^(2) / 20 + (E358 - 20)^(2) / 20 + (F358 - 20)^(2) / 20 + (G358 - 20)^(2) / 20
I358 = Sum(abs(B358:G358 - 20))
J358: Max[B358:G358] - Min[B358:G358]
K358 = Max(abs(B358:G358 - 20))
L358: CountIf[x < 11, B358:G358] + CountIf[x > 29, B358:G358]
A359 = Sequence(Random[1, 6], k, 1, 120)
C359 = CountIf(x ≟ 2, A359)
D359 = CountIf(x ≟ 3, A359)
E359 = CountIf(x ≟ 4, A359)
F359 = CountIf(x ≟ 5, A359)
G359 = CountIf(x ≟ 6, A359)
B359 = CountIf(x ≟ 1, A359)
H359: (B359 - 20)^(2) / 20 + (C359 - 20)^(2) / 20 + (D359 - 20)^(2) / 20 + (E359 - 20)^(2) / 20 + (F359 - 20)^(2) / 20 + (G359 - 20)^(2) / 20
I359 = Sum(abs(B359:G359 - 20))
J359: Max[B359:G359] - Min[B359:G359]
K359 = Max(abs(B359:G359 - 20))
L359: CountIf[x < 11, B359:G359] + CountIf[x > 29, B359:G359]
A360 = Sequence(Random[1, 6], k, 1, 120)
C360 = CountIf(x ≟ 2, A360)
D360 = CountIf(x ≟ 3, A360)
E360 = CountIf(x ≟ 4, A360)
F360 = CountIf(x ≟ 5, A360)
G360 = CountIf(x ≟ 6, A360)
B360 = CountIf(x ≟ 1, A360)
H360: (B360 - 20)^(2) / 20 + (C360 - 20)^(2) / 20 + (D360 - 20)^(2) / 20 + (E360 - 20)^(2) / 20 + (F360 - 20)^(2) / 20 + (G360 - 20)^(2) / 20
I360 = Sum(abs(B360:G360 - 20))
J360: Max[B360:G360] - Min[B360:G360]
K360 = Max(abs(B360:G360 - 20))
L360: CountIf[x < 11, B360:G360] + CountIf[x > 29, B360:G360]
A361 = Sequence(Random[1, 6], k, 1, 120)
C361 = CountIf(x ≟ 2, A361)
D361 = CountIf(x ≟ 3, A361)
E361 = CountIf(x ≟ 4, A361)
F361 = CountIf(x ≟ 5, A361)
G361 = CountIf(x ≟ 6, A361)
B361 = CountIf(x ≟ 1, A361)
H361: (B361 - 20)^(2) / 20 + (C361 - 20)^(2) / 20 + (D361 - 20)^(2) / 20 + (E361 - 20)^(2) / 20 + (F361 - 20)^(2) / 20 + (G361 - 20)^(2) / 20
I361 = Sum(abs(B361:G361 - 20))
J361: Max[B361:G361] - Min[B361:G361]
K361 = Max(abs(B361:G361 - 20))
L361: CountIf[x < 11, B361:G361] + CountIf[x > 29, B361:G361]
A362 = Sequence(Random[1, 6], k, 1, 120)
C362 = CountIf(x ≟ 2, A362)
D362 = CountIf(x ≟ 3, A362)
E362 = CountIf(x ≟ 4, A362)
F362 = CountIf(x ≟ 5, A362)
G362 = CountIf(x ≟ 6, A362)
B362 = CountIf(x ≟ 1, A362)
H362: (B362 - 20)^(2) / 20 + (C362 - 20)^(2) / 20 + (D362 - 20)^(2) / 20 + (E362 - 20)^(2) / 20 + (F362 - 20)^(2) / 20 + (G362 - 20)^(2) / 20
I362 = Sum(abs(B362:G362 - 20))
J362: Max[B362:G362] - Min[B362:G362]
K362 = Max(abs(B362:G362 - 20))
L362: CountIf[x < 11, B362:G362] + CountIf[x > 29, B362:G362]
A363 = Sequence(Random[1, 6], k, 1, 120)
C363 = CountIf(x ≟ 2, A363)
D363 = CountIf(x ≟ 3, A363)
E363 = CountIf(x ≟ 4, A363)
F363 = CountIf(x ≟ 5, A363)
G363 = CountIf(x ≟ 6, A363)
B363 = CountIf(x ≟ 1, A363)
H363: (B363 - 20)^(2) / 20 + (C363 - 20)^(2) / 20 + (D363 - 20)^(2) / 20 + (E363 - 20)^(2) / 20 + (F363 - 20)^(2) / 20 + (G363 - 20)^(2) / 20
I363 = Sum(abs(B363:G363 - 20))
J363: Max[B363:G363] - Min[B363:G363]
K363 = Max(abs(B363:G363 - 20))
L363: CountIf[x < 11, B363:G363] + CountIf[x > 29, B363:G363]
A364 = Sequence(Random[1, 6], k, 1, 120)
C364 = CountIf(x ≟ 2, A364)
D364 = CountIf(x ≟ 3, A364)
E364 = CountIf(x ≟ 4, A364)
F364 = CountIf(x ≟ 5, A364)
G364 = CountIf(x ≟ 6, A364)
B364 = CountIf(x ≟ 1, A364)
H364: (B364 - 20)^(2) / 20 + (C364 - 20)^(2) / 20 + (D364 - 20)^(2) / 20 + (E364 - 20)^(2) / 20 + (F364 - 20)^(2) / 20 + (G364 - 20)^(2) / 20
I364 = Sum(abs(B364:G364 - 20))
J364: Max[B364:G364] - Min[B364:G364]
K364 = Max(abs(B364:G364 - 20))
L364: CountIf[x < 11, B364:G364] + CountIf[x > 29, B364:G364]
A365 = Sequence(Random[1, 6], k, 1, 120)
C365 = CountIf(x ≟ 2, A365)
D365 = CountIf(x ≟ 3, A365)
E365 = CountIf(x ≟ 4, A365)
F365 = CountIf(x ≟ 5, A365)
G365 = CountIf(x ≟ 6, A365)
B365 = CountIf(x ≟ 1, A365)
H365: (B365 - 20)^(2) / 20 + (C365 - 20)^(2) / 20 + (D365 - 20)^(2) / 20 + (E365 - 20)^(2) / 20 + (F365 - 20)^(2) / 20 + (G365 - 20)^(2) / 20
I365 = Sum(abs(B365:G365 - 20))
J365: Max[B365:G365] - Min[B365:G365]
K365 = Max(abs(B365:G365 - 20))
L365: CountIf[x < 11, B365:G365] + CountIf[x > 29, B365:G365]
A366 = Sequence(Random[1, 6], k, 1, 120)
C366 = CountIf(x ≟ 2, A366)
D366 = CountIf(x ≟ 3, A366)
E366 = CountIf(x ≟ 4, A366)
F366 = CountIf(x ≟ 5, A366)
G366 = CountIf(x ≟ 6, A366)
B366 = CountIf(x ≟ 1, A366)
H366: (B366 - 20)^(2) / 20 + (C366 - 20)^(2) / 20 + (D366 - 20)^(2) / 20 + (E366 - 20)^(2) / 20 + (F366 - 20)^(2) / 20 + (G366 - 20)^(2) / 20
I366 = Sum(abs(B366:G366 - 20))
J366: Max[B366:G366] - Min[B366:G366]
K366 = Max(abs(B366:G366 - 20))
L366: CountIf[x < 11, B366:G366] + CountIf[x > 29, B366:G366]
A367 = Sequence(Random[1, 6], k, 1, 120)
C367 = CountIf(x ≟ 2, A367)
D367 = CountIf(x ≟ 3, A367)
E367 = CountIf(x ≟ 4, A367)
F367 = CountIf(x ≟ 5, A367)
G367 = CountIf(x ≟ 6, A367)
B367 = CountIf(x ≟ 1, A367)
H367: (B367 - 20)^(2) / 20 + (C367 - 20)^(2) / 20 + (D367 - 20)^(2) / 20 + (E367 - 20)^(2) / 20 + (F367 - 20)^(2) / 20 + (G367 - 20)^(2) / 20
I367 = Sum(abs(B367:G367 - 20))
J367: Max[B367:G367] - Min[B367:G367]
K367 = Max(abs(B367:G367 - 20))
L367: CountIf[x < 11, B367:G367] + CountIf[x > 29, B367:G367]
A368 = Sequence(Random[1, 6], k, 1, 120)
C368 = CountIf(x ≟ 2, A368)
D368 = CountIf(x ≟ 3, A368)
E368 = CountIf(x ≟ 4, A368)
F368 = CountIf(x ≟ 5, A368)
G368 = CountIf(x ≟ 6, A368)
B368 = CountIf(x ≟ 1, A368)
H368: (B368 - 20)^(2) / 20 + (C368 - 20)^(2) / 20 + (D368 - 20)^(2) / 20 + (E368 - 20)^(2) / 20 + (F368 - 20)^(2) / 20 + (G368 - 20)^(2) / 20
I368 = Sum(abs(B368:G368 - 20))
J368: Max[B368:G368] - Min[B368:G368]
K368 = Max(abs(B368:G368 - 20))
L368: CountIf[x < 11, B368:G368] + CountIf[x > 29, B368:G368]
A369 = Sequence(Random[1, 6], k, 1, 120)
C369 = CountIf(x ≟ 2, A369)
D369 = CountIf(x ≟ 3, A369)
E369 = CountIf(x ≟ 4, A369)
F369 = CountIf(x ≟ 5, A369)
G369 = CountIf(x ≟ 6, A369)
B369 = CountIf(x ≟ 1, A369)
H369: (B369 - 20)^(2) / 20 + (C369 - 20)^(2) / 20 + (D369 - 20)^(2) / 20 + (E369 - 20)^(2) / 20 + (F369 - 20)^(2) / 20 + (G369 - 20)^(2) / 20
I369 = Sum(abs(B369:G369 - 20))
J369: Max[B369:G369] - Min[B369:G369]
K369 = Max(abs(B369:G369 - 20))
L369: CountIf[x < 11, B369:G369] + CountIf[x > 29, B369:G369]
A370 = Sequence(Random[1, 6], k, 1, 120)
C370 = CountIf(x ≟ 2, A370)
D370 = CountIf(x ≟ 3, A370)
E370 = CountIf(x ≟ 4, A370)
F370 = CountIf(x ≟ 5, A370)
G370 = CountIf(x ≟ 6, A370)
B370 = CountIf(x ≟ 1, A370)
H370: (B370 - 20)^(2) / 20 + (C370 - 20)^(2) / 20 + (D370 - 20)^(2) / 20 + (E370 - 20)^(2) / 20 + (F370 - 20)^(2) / 20 + (G370 - 20)^(2) / 20
I370 = Sum(abs(B370:G370 - 20))
J370: Max[B370:G370] - Min[B370:G370]
K370 = Max(abs(B370:G370 - 20))
L370: CountIf[x < 11, B370:G370] + CountIf[x > 29, B370:G370]
A371 = Sequence(Random[1, 6], k, 1, 120)
C371 = CountIf(x ≟ 2, A371)
D371 = CountIf(x ≟ 3, A371)
E371 = CountIf(x ≟ 4, A371)
F371 = CountIf(x ≟ 5, A371)
G371 = CountIf(x ≟ 6, A371)
B371 = CountIf(x ≟ 1, A371)
H371: (B371 - 20)^(2) / 20 + (C371 - 20)^(2) / 20 + (D371 - 20)^(2) / 20 + (E371 - 20)^(2) / 20 + (F371 - 20)^(2) / 20 + (G371 - 20)^(2) / 20
I371 = Sum(abs(B371:G371 - 20))
J371: Max[B371:G371] - Min[B371:G371]
K371 = Max(abs(B371:G371 - 20))
L371: CountIf[x < 11, B371:G371] + CountIf[x > 29, B371:G371]
A372 = Sequence(Random[1, 6], k, 1, 120)
C372 = CountIf(x ≟ 2, A372)
D372 = CountIf(x ≟ 3, A372)
E372 = CountIf(x ≟ 4, A372)
F372 = CountIf(x ≟ 5, A372)
G372 = CountIf(x ≟ 6, A372)
B372 = CountIf(x ≟ 1, A372)
H372: (B372 - 20)^(2) / 20 + (C372 - 20)^(2) / 20 + (D372 - 20)^(2) / 20 + (E372 - 20)^(2) / 20 + (F372 - 20)^(2) / 20 + (G372 - 20)^(2) / 20
I372 = Sum(abs(B372:G372 - 20))
J372: Max[B372:G372] - Min[B372:G372]
K372 = Max(abs(B372:G372 - 20))
L372: CountIf[x < 11, B372:G372] + CountIf[x > 29, B372:G372]
A373 = Sequence(Random[1, 6], k, 1, 120)
C373 = CountIf(x ≟ 2, A373)
D373 = CountIf(x ≟ 3, A373)
E373 = CountIf(x ≟ 4, A373)
F373 = CountIf(x ≟ 5, A373)
G373 = CountIf(x ≟ 6, A373)
B373 = CountIf(x ≟ 1, A373)
H373: (B373 - 20)^(2) / 20 + (C373 - 20)^(2) / 20 + (D373 - 20)^(2) / 20 + (E373 - 20)^(2) / 20 + (F373 - 20)^(2) / 20 + (G373 - 20)^(2) / 20
I373 = Sum(abs(B373:G373 - 20))
J373: Max[B373:G373] - Min[B373:G373]
K373 = Max(abs(B373:G373 - 20))
L373: CountIf[x < 11, B373:G373] + CountIf[x > 29, B373:G373]
A374 = Sequence(Random[1, 6], k, 1, 120)
C374 = CountIf(x ≟ 2, A374)
D374 = CountIf(x ≟ 3, A374)
E374 = CountIf(x ≟ 4, A374)
F374 = CountIf(x ≟ 5, A374)
G374 = CountIf(x ≟ 6, A374)
B374 = CountIf(x ≟ 1, A374)
H374: (B374 - 20)^(2) / 20 + (C374 - 20)^(2) / 20 + (D374 - 20)^(2) / 20 + (E374 - 20)^(2) / 20 + (F374 - 20)^(2) / 20 + (G374 - 20)^(2) / 20
I374 = Sum(abs(B374:G374 - 20))
J374: Max[B374:G374] - Min[B374:G374]
K374 = Max(abs(B374:G374 - 20))
L374: CountIf[x < 11, B374:G374] + CountIf[x > 29, B374:G374]
I375 = Sum(abs(B375:G375 - 20))
J375: Max[B375:G375] - Min[B375:G375]
K375 = Max(abs(B375:G375 - 20))
L375: CountIf[x < 11, B375:G375] + CountIf[x > 29, B375:G375]
A376 = Sequence(Random[1, 6], k, 1, 120)
C376 = CountIf(x ≟ 2, A376)
D376 = CountIf(x ≟ 3, A376)
E376 = CountIf(x ≟ 4, A376)
F376 = CountIf(x ≟ 5, A376)
G376 = CountIf(x ≟ 6, A376)
B376 = CountIf(x ≟ 1, A376)
H376: (B376 - 20)^(2) / 20 + (C376 - 20)^(2) / 20 + (D376 - 20)^(2) / 20 + (E376 - 20)^(2) / 20 + (F376 - 20)^(2) / 20 + (G376 - 20)^(2) / 20
I376 = Sum(abs(B376:G376 - 20))
J376: Max[B376:G376] - Min[B376:G376]
K376 = Max(abs(B376:G376 - 20))
L376: CountIf[x < 11, B376:G376] + CountIf[x > 29, B376:G376]
A377 = Sequence(Random[1, 6], k, 1, 120)
C377 = CountIf(x ≟ 2, A377)
D377 = CountIf(x ≟ 3, A377)
E377 = CountIf(x ≟ 4, A377)
F377 = CountIf(x ≟ 5, A377)
G377 = CountIf(x ≟ 6, A377)
B377 = CountIf(x ≟ 1, A377)
H377: (B377 - 20)^(2) / 20 + (C377 - 20)^(2) / 20 + (D377 - 20)^(2) / 20 + (E377 - 20)^(2) / 20 + (F377 - 20)^(2) / 20 + (G377 - 20)^(2) / 20
I377 = Sum(abs(B377:G377 - 20))
J377: Max[B377:G377] - Min[B377:G377]
K377 = Max(abs(B377:G377 - 20))
L377: CountIf[x < 11, B377:G377] + CountIf[x > 29, B377:G377]
A378 = Sequence(Random[1, 6], k, 1, 120)
C378 = CountIf(x ≟ 2, A378)
D378 = CountIf(x ≟ 3, A378)
E378 = CountIf(x ≟ 4, A378)
F378 = CountIf(x ≟ 5, A378)
G378 = CountIf(x ≟ 6, A378)
B378 = CountIf(x ≟ 1, A378)
H378: (B378 - 20)^(2) / 20 + (C378 - 20)^(2) / 20 + (D378 - 20)^(2) / 20 + (E378 - 20)^(2) / 20 + (F378 - 20)^(2) / 20 + (G378 - 20)^(2) / 20
I378 = Sum(abs(B378:G378 - 20))
J378: Max[B378:G378] - Min[B378:G378]
K378 = Max(abs(B378:G378 - 20))
L378: CountIf[x < 11, B378:G378] + CountIf[x > 29, B378:G378]
A379 = Sequence(Random[1, 6], k, 1, 120)
C379 = CountIf(x ≟ 2, A379)
D379 = CountIf(x ≟ 3, A379)
E379 = CountIf(x ≟ 4, A379)
F379 = CountIf(x ≟ 5, A379)
G379 = CountIf(x ≟ 6, A379)
B379 = CountIf(x ≟ 1, A379)
H379: (B379 - 20)^(2) / 20 + (C379 - 20)^(2) / 20 + (D379 - 20)^(2) / 20 + (E379 - 20)^(2) / 20 + (F379 - 20)^(2) / 20 + (G379 - 20)^(2) / 20
I379 = Sum(abs(B379:G379 - 20))
J379: Max[B379:G379] - Min[B379:G379]
K379 = Max(abs(B379:G379 - 20))
L379: CountIf[x < 11, B379:G379] + CountIf[x > 29, B379:G379]
A380 = Sequence(Random[1, 6], k, 1, 120)
C380 = CountIf(x ≟ 2, A380)
D380 = CountIf(x ≟ 3, A380)
E380 = CountIf(x ≟ 4, A380)
F380 = CountIf(x ≟ 5, A380)
G380 = CountIf(x ≟ 6, A380)
B380 = CountIf(x ≟ 1, A380)
H380: (B380 - 20)^(2) / 20 + (C380 - 20)^(2) / 20 + (D380 - 20)^(2) / 20 + (E380 - 20)^(2) / 20 + (F380 - 20)^(2) / 20 + (G380 - 20)^(2) / 20
I380 = Sum(abs(B380:G380 - 20))
J380: Max[B380:G380] - Min[B380:G380]
K380 = Max(abs(B380:G380 - 20))
L380: CountIf[x < 11, B380:G380] + CountIf[x > 29, B380:G380]
A381 = Sequence(Random[1, 6], k, 1, 120)
C381 = CountIf(x ≟ 2, A381)
D381 = CountIf(x ≟ 3, A381)
E381 = CountIf(x ≟ 4, A381)
F381 = CountIf(x ≟ 5, A381)
G381 = CountIf(x ≟ 6, A381)
B381 = CountIf(x ≟ 1, A381)
H381: (B381 - 20)^(2) / 20 + (C381 - 20)^(2) / 20 + (D381 - 20)^(2) / 20 + (E381 - 20)^(2) / 20 + (F381 - 20)^(2) / 20 + (G381 - 20)^(2) / 20
I381 = Sum(abs(B381:G381 - 20))
J381: Max[B381:G381] - Min[B381:G381]
K381 = Max(abs(B381:G381 - 20))
L381: CountIf[x < 11, B381:G381] + CountIf[x > 29, B381:G381]
A382 = Sequence(Random[1, 6], k, 1, 120)
C382 = CountIf(x ≟ 2, A382)
D382 = CountIf(x ≟ 3, A382)
E382 = CountIf(x ≟ 4, A382)
F382 = CountIf(x ≟ 5, A382)
G382 = CountIf(x ≟ 6, A382)
B382 = CountIf(x ≟ 1, A382)
H382: (B382 - 20)^(2) / 20 + (C382 - 20)^(2) / 20 + (D382 - 20)^(2) / 20 + (E382 - 20)^(2) / 20 + (F382 - 20)^(2) / 20 + (G382 - 20)^(2) / 20
I382 = Sum(abs(B382:G382 - 20))
J382: Max[B382:G382] - Min[B382:G382]
K382 = Max(abs(B382:G382 - 20))
L382: CountIf[x < 11, B382:G382] + CountIf[x > 29, B382:G382]
A383 = Sequence(Random[1, 6], k, 1, 120)
C383 = CountIf(x ≟ 2, A383)
D383 = CountIf(x ≟ 3, A383)
E383 = CountIf(x ≟ 4, A383)
F383 = CountIf(x ≟ 5, A383)
G383 = CountIf(x ≟ 6, A383)
B383 = CountIf(x ≟ 1, A383)
H383: (B383 - 20)^(2) / 20 + (C383 - 20)^(2) / 20 + (D383 - 20)^(2) / 20 + (E383 - 20)^(2) / 20 + (F383 - 20)^(2) / 20 + (G383 - 20)^(2) / 20
I383 = Sum(abs(B383:G383 - 20))
J383: Max[B383:G383] - Min[B383:G383]
K383 = Max(abs(B383:G383 - 20))
L383: CountIf[x < 11, B383:G383] + CountIf[x > 29, B383:G383]
A384 = Sequence(Random[1, 6], k, 1, 120)
C384 = CountIf(x ≟ 2, A384)
D384 = CountIf(x ≟ 3, A384)
E384 = CountIf(x ≟ 4, A384)
F384 = CountIf(x ≟ 5, A384)
G384 = CountIf(x ≟ 6, A384)
B384 = CountIf(x ≟ 1, A384)
H384: (B384 - 20)^(2) / 20 + (C384 - 20)^(2) / 20 + (D384 - 20)^(2) / 20 + (E384 - 20)^(2) / 20 + (F384 - 20)^(2) / 20 + (G384 - 20)^(2) / 20
I384 = Sum(abs(B384:G384 - 20))
J384: Max[B384:G384] - Min[B384:G384]
K384 = Max(abs(B384:G384 - 20))
L384: CountIf[x < 11, B384:G384] + CountIf[x > 29, B384:G384]
A385 = Sequence(Random[1, 6], k, 1, 120)
C385 = CountIf(x ≟ 2, A385)
D385 = CountIf(x ≟ 3, A385)
E385 = CountIf(x ≟ 4, A385)
F385 = CountIf(x ≟ 5, A385)
G385 = CountIf(x ≟ 6, A385)
B385 = CountIf(x ≟ 1, A385)
H385: (B385 - 20)^(2) / 20 + (C385 - 20)^(2) / 20 + (D385 - 20)^(2) / 20 + (E385 - 20)^(2) / 20 + (F385 - 20)^(2) / 20 + (G385 - 20)^(2) / 20
I385 = Sum(abs(B385:G385 - 20))
J385: Max[B385:G385] - Min[B385:G385]
K385 = Max(abs(B385:G385 - 20))
L385: CountIf[x < 11, B385:G385] + CountIf[x > 29, B385:G385]
A386 = Sequence(Random[1, 6], k, 1, 120)
C386 = CountIf(x ≟ 2, A386)
D386 = CountIf(x ≟ 3, A386)
E386 = CountIf(x ≟ 4, A386)
F386 = CountIf(x ≟ 5, A386)
G386 = CountIf(x ≟ 6, A386)
B386 = CountIf(x ≟ 1, A386)
H386: (B386 - 20)^(2) / 20 + (C386 - 20)^(2) / 20 + (D386 - 20)^(2) / 20 + (E386 - 20)^(2) / 20 + (F386 - 20)^(2) / 20 + (G386 - 20)^(2) / 20
I386 = Sum(abs(B386:G386 - 20))
J386: Max[B386:G386] - Min[B386:G386]
K386 = Max(abs(B386:G386 - 20))
L386: CountIf[x < 11, B386:G386] + CountIf[x > 29, B386:G386]
A387 = Sequence(Random[1, 6], k, 1, 120)
C387 = CountIf(x ≟ 2, A387)
D387 = CountIf(x ≟ 3, A387)
E387 = CountIf(x ≟ 4, A387)
F387 = CountIf(x ≟ 5, A387)
G387 = CountIf(x ≟ 6, A387)
B387 = CountIf(x ≟ 1, A387)
H387: (B387 - 20)^(2) / 20 + (C387 - 20)^(2) / 20 + (D387 - 20)^(2) / 20 + (E387 - 20)^(2) / 20 + (F387 - 20)^(2) / 20 + (G387 - 20)^(2) / 20
I387 = Sum(abs(B387:G387 - 20))
J387: Max[B387:G387] - Min[B387:G387]
K387 = Max(abs(B387:G387 - 20))
L387: CountIf[x < 11, B387:G387] + CountIf[x > 29, B387:G387]
A388 = Sequence(Random[1, 6], k, 1, 120)
C388 = CountIf(x ≟ 2, A388)
D388 = CountIf(x ≟ 3, A388)
E388 = CountIf(x ≟ 4, A388)
F388 = CountIf(x ≟ 5, A388)
G388 = CountIf(x ≟ 6, A388)
B388 = CountIf(x ≟ 1, A388)
H388: (B388 - 20)^(2) / 20 + (C388 - 20)^(2) / 20 + (D388 - 20)^(2) / 20 + (E388 - 20)^(2) / 20 + (F388 - 20)^(2) / 20 + (G388 - 20)^(2) / 20
I388 = Sum(abs(B388:G388 - 20))
J388: Max[B388:G388] - Min[B388:G388]
K388 = Max(abs(B388:G388 - 20))
L388: CountIf[x < 11, B388:G388] + CountIf[x > 29, B388:G388]
A389 = Sequence(Random[1, 6], k, 1, 120)
C389 = CountIf(x ≟ 2, A389)
D389 = CountIf(x ≟ 3, A389)
E389 = CountIf(x ≟ 4, A389)
F389 = CountIf(x ≟ 5, A389)
G389 = CountIf(x ≟ 6, A389)
B389 = CountIf(x ≟ 1, A389)
H389: (B389 - 20)^(2) / 20 + (C389 - 20)^(2) / 20 + (D389 - 20)^(2) / 20 + (E389 - 20)^(2) / 20 + (F389 - 20)^(2) / 20 + (G389 - 20)^(2) / 20
I389 = Sum(abs(B389:G389 - 20))
J389: Max[B389:G389] - Min[B389:G389]
K389 = Max(abs(B389:G389 - 20))
L389: CountIf[x < 11, B389:G389] + CountIf[x > 29, B389:G389]
A390 = Sequence(Random[1, 6], k, 1, 120)
C390 = CountIf(x ≟ 2, A390)
D390 = CountIf(x ≟ 3, A390)
E390 = CountIf(x ≟ 4, A390)
F390 = CountIf(x ≟ 5, A390)
G390 = CountIf(x ≟ 6, A390)
B390 = CountIf(x ≟ 1, A390)
H390: (B390 - 20)^(2) / 20 + (C390 - 20)^(2) / 20 + (D390 - 20)^(2) / 20 + (E390 - 20)^(2) / 20 + (F390 - 20)^(2) / 20 + (G390 - 20)^(2) / 20
I390 = Sum(abs(B390:G390 - 20))
J390: Max[B390:G390] - Min[B390:G390]
K390 = Max(abs(B390:G390 - 20))
L390: CountIf[x < 11, B390:G390] + CountIf[x > 29, B390:G390]
A391 = Sequence(Random[1, 6], k, 1, 120)
C391 = CountIf(x ≟ 2, A391)
D391 = CountIf(x ≟ 3, A391)
E391 = CountIf(x ≟ 4, A391)
F391 = CountIf(x ≟ 5, A391)
G391 = CountIf(x ≟ 6, A391)
B391 = CountIf(x ≟ 1, A391)
H391: (B391 - 20)^(2) / 20 + (C391 - 20)^(2) / 20 + (D391 - 20)^(2) / 20 + (E391 - 20)^(2) / 20 + (F391 - 20)^(2) / 20 + (G391 - 20)^(2) / 20
I391 = Sum(abs(B391:G391 - 20))
J391: Max[B391:G391] - Min[B391:G391]
K391 = Max(abs(B391:G391 - 20))
L391: CountIf[x < 11, B391:G391] + CountIf[x > 29, B391:G391]
A392 = Sequence(Random[1, 6], k, 1, 120)
C392 = CountIf(x ≟ 2, A392)
D392 = CountIf(x ≟ 3, A392)
E392 = CountIf(x ≟ 4, A392)
F392 = CountIf(x ≟ 5, A392)
G392 = CountIf(x ≟ 6, A392)
B392 = CountIf(x ≟ 1, A392)
H392: (B392 - 20)^(2) / 20 + (C392 - 20)^(2) / 20 + (D392 - 20)^(2) / 20 + (E392 - 20)^(2) / 20 + (F392 - 20)^(2) / 20 + (G392 - 20)^(2) / 20
I392 = Sum(abs(B392:G392 - 20))
J392: Max[B392:G392] - Min[B392:G392]
K392 = Max(abs(B392:G392 - 20))
L392: CountIf[x < 11, B392:G392] + CountIf[x > 29, B392:G392]
A393 = Sequence(Random[1, 6], k, 1, 120)
C393 = CountIf(x ≟ 2, A393)
D393 = CountIf(x ≟ 3, A393)
E393 = CountIf(x ≟ 4, A393)
F393 = CountIf(x ≟ 5, A393)
G393 = CountIf(x ≟ 6, A393)
B393 = CountIf(x ≟ 1, A393)
H393: (B393 - 20)^(2) / 20 + (C393 - 20)^(2) / 20 + (D393 - 20)^(2) / 20 + (E393 - 20)^(2) / 20 + (F393 - 20)^(2) / 20 + (G393 - 20)^(2) / 20
I393 = Sum(abs(B393:G393 - 20))
J393: Max[B393:G393] - Min[B393:G393]
K393 = Max(abs(B393:G393 - 20))
L393: CountIf[x < 11, B393:G393] + CountIf[x > 29, B393:G393]
A394 = Sequence(Random[1, 6], k, 1, 120)
C394 = CountIf(x ≟ 2, A394)
D394 = CountIf(x ≟ 3, A394)
E394 = CountIf(x ≟ 4, A394)
F394 = CountIf(x ≟ 5, A394)
G394 = CountIf(x ≟ 6, A394)
B394 = CountIf(x ≟ 1, A394)
H394: (B394 - 20)^(2) / 20 + (C394 - 20)^(2) / 20 + (D394 - 20)^(2) / 20 + (E394 - 20)^(2) / 20 + (F394 - 20)^(2) / 20 + (G394 - 20)^(2) / 20
I394 = Sum(abs(B394:G394 - 20))
J394: Max[B394:G394] - Min[B394:G394]
K394 = Max(abs(B394:G394 - 20))
L394: CountIf[x < 11, B394:G394] + CountIf[x > 29, B394:G394]
A395 = Sequence(Random[1, 6], k, 1, 120)
C395 = CountIf(x ≟ 2, A395)
D395 = CountIf(x ≟ 3, A395)
E395 = CountIf(x ≟ 4, A395)
F395 = CountIf(x ≟ 5, A395)
G395 = CountIf(x ≟ 6, A395)
B395 = CountIf(x ≟ 1, A395)
H395: (B395 - 20)^(2) / 20 + (C395 - 20)^(2) / 20 + (D395 - 20)^(2) / 20 + (E395 - 20)^(2) / 20 + (F395 - 20)^(2) / 20 + (G395 - 20)^(2) / 20
I395 = Sum(abs(B395:G395 - 20))
J395: Max[B395:G395] - Min[B395:G395]
K395 = Max(abs(B395:G395 - 20))
L395: CountIf[x < 11, B395:G395] + CountIf[x > 29, B395:G395]
A396 = Sequence(Random[1, 6], k, 1, 120)
C396 = CountIf(x ≟ 2, A396)
D396 = CountIf(x ≟ 3, A396)
E396 = CountIf(x ≟ 4, A396)
F396 = CountIf(x ≟ 5, A396)
G396 = CountIf(x ≟ 6, A396)
B396 = CountIf(x ≟ 1, A396)
H396: (B396 - 20)^(2) / 20 + (C396 - 20)^(2) / 20 + (D396 - 20)^(2) / 20 + (E396 - 20)^(2) / 20 + (F396 - 20)^(2) / 20 + (G396 - 20)^(2) / 20
I396 = Sum(abs(B396:G396 - 20))
J396: Max[B396:G396] - Min[B396:G396]
K396 = Max(abs(B396:G396 - 20))
L396: CountIf[x < 11, B396:G396] + CountIf[x > 29, B396:G396]
A397 = Sequence(Random[1, 6], k, 1, 120)
C397 = CountIf(x ≟ 2, A397)
D397 = CountIf(x ≟ 3, A397)
E397 = CountIf(x ≟ 4, A397)
F397 = CountIf(x ≟ 5, A397)
G397 = CountIf(x ≟ 6, A397)
B397 = CountIf(x ≟ 1, A397)
H397: (B397 - 20)^(2) / 20 + (C397 - 20)^(2) / 20 + (D397 - 20)^(2) / 20 + (E397 - 20)^(2) / 20 + (F397 - 20)^(2) / 20 + (G397 - 20)^(2) / 20
I397 = Sum(abs(B397:G397 - 20))
J397: Max[B397:G397] - Min[B397:G397]
K397 = Max(abs(B397:G397 - 20))
L397: CountIf[x < 11, B397:G397] + CountIf[x > 29, B397:G397]
A398 = Sequence(Random[1, 6], k, 1, 120)
C398 = CountIf(x ≟ 2, A398)
D398 = CountIf(x ≟ 3, A398)
E398 = CountIf(x ≟ 4, A398)
F398 = CountIf(x ≟ 5, A398)
G398 = CountIf(x ≟ 6, A398)
B398 = CountIf(x ≟ 1, A398)
H398: (B398 - 20)^(2) / 20 + (C398 - 20)^(2) / 20 + (D398 - 20)^(2) / 20 + (E398 - 20)^(2) / 20 + (F398 - 20)^(2) / 20 + (G398 - 20)^(2) / 20
I398 = Sum(abs(B398:G398 - 20))
J398: Max[B398:G398] - Min[B398:G398]
K398 = Max(abs(B398:G398 - 20))
L398: CountIf[x < 11, B398:G398] + CountIf[x > 29, B398:G398]
A399 = Sequence(Random[1, 6], k, 1, 120)
C399 = CountIf(x ≟ 2, A399)
D399 = CountIf(x ≟ 3, A399)
E399 = CountIf(x ≟ 4, A399)
F399 = CountIf(x ≟ 5, A399)
G399 = CountIf(x ≟ 6, A399)
B399 = CountIf(x ≟ 1, A399)
H399: (B399 - 20)^(2) / 20 + (C399 - 20)^(2) / 20 + (D399 - 20)^(2) / 20 + (E399 - 20)^(2) / 20 + (F399 - 20)^(2) / 20 + (G399 - 20)^(2) / 20
I399 = Sum(abs(B399:G399 - 20))
J399: Max[B399:G399] - Min[B399:G399]
K399 = Max(abs(B399:G399 - 20))
L399: CountIf[x < 11, B399:G399] + CountIf[x > 29, B399:G399]
A400 = Sequence(Random[1, 6], k, 1, 120)
C400 = CountIf(x ≟ 2, A400)
D400 = CountIf(x ≟ 3, A400)
E400 = CountIf(x ≟ 4, A400)
F400 = CountIf(x ≟ 5, A400)
G400 = CountIf(x ≟ 6, A400)
B400 = CountIf(x ≟ 1, A400)
H400: (B400 - 20)^(2) / 20 + (C400 - 20)^(2) / 20 + (D400 - 20)^(2) / 20 + (E400 - 20)^(2) / 20 + (F400 - 20)^(2) / 20 + (G400 - 20)^(2) / 20
I400 = Sum(abs(B400:G400 - 20))
J400: Max[B400:G400] - Min[B400:G400]
K400 = Max(abs(B400:G400 - 20))
L400: CountIf[x < 11, B400:G400] + CountIf[x > 29, B400:G400]
A401 = Sequence(Random[1, 6], k, 1, 120)
C401 = CountIf(x ≟ 2, A401)
D401 = CountIf(x ≟ 3, A401)
E401 = CountIf(x ≟ 4, A401)
F401 = CountIf(x ≟ 5, A401)
G401 = CountIf(x ≟ 6, A401)
B401 = CountIf(x ≟ 1, A401)
H401: (B401 - 20)^(2) / 20 + (C401 - 20)^(2) / 20 + (D401 - 20)^(2) / 20 + (E401 - 20)^(2) / 20 + (F401 - 20)^(2) / 20 + (G401 - 20)^(2) / 20
I401 = Sum(abs(B401:G401 - 20))
J401: Max[B401:G401] - Min[B401:G401]
K401 = Max(abs(B401:G401 - 20))
L401: CountIf[x < 11, B401:G401] + CountIf[x > 29, B401:G401]
A402 = Sequence(Random[1, 6], k, 1, 120)
C402 = CountIf(x ≟ 2, A402)
D402 = CountIf(x ≟ 3, A402)
E402 = CountIf(x ≟ 4, A402)
F402 = CountIf(x ≟ 5, A402)
G402 = CountIf(x ≟ 6, A402)
B402 = CountIf(x ≟ 1, A402)
H402: (B402 - 20)^(2) / 20 + (C402 - 20)^(2) / 20 + (D402 - 20)^(2) / 20 + (E402 - 20)^(2) / 20 + (F402 - 20)^(2) / 20 + (G402 - 20)^(2) / 20
I402 = Sum(abs(B402:G402 - 20))
J402: Max[B402:G402] - Min[B402:G402]
K402 = Max(abs(B402:G402 - 20))
L402: CountIf[x < 11, B402:G402] + CountIf[x > 29, B402:G402]
A403 = Sequence(Random[1, 6], k, 1, 120)
C403 = CountIf(x ≟ 2, A403)
D403 = CountIf(x ≟ 3, A403)
E403 = CountIf(x ≟ 4, A403)
F403 = CountIf(x ≟ 5, A403)
G403 = CountIf(x ≟ 6, A403)
B403 = CountIf(x ≟ 1, A403)
H403: (B403 - 20)^(2) / 20 + (C403 - 20)^(2) / 20 + (D403 - 20)^(2) / 20 + (E403 - 20)^(2) / 20 + (F403 - 20)^(2) / 20 + (G403 - 20)^(2) / 20
I403 = Sum(abs(B403:G403 - 20))
J403: Max[B403:G403] - Min[B403:G403]
K403 = Max(abs(B403:G403 - 20))
L403: CountIf[x < 11, B403:G403] + CountIf[x > 29, B403:G403]
A404 = Sequence(Random[1, 6], k, 1, 120)
C404 = CountIf(x ≟ 2, A404)
D404 = CountIf(x ≟ 3, A404)
E404 = CountIf(x ≟ 4, A404)
F404 = CountIf(x ≟ 5, A404)
G404 = CountIf(x ≟ 6, A404)
B404 = CountIf(x ≟ 1, A404)
H404: (B404 - 20)^(2) / 20 + (C404 - 20)^(2) / 20 + (D404 - 20)^(2) / 20 + (E404 - 20)^(2) / 20 + (F404 - 20)^(2) / 20 + (G404 - 20)^(2) / 20
I404 = Sum(abs(B404:G404 - 20))
J404: Max[B404:G404] - Min[B404:G404]
K404 = Max(abs(B404:G404 - 20))
L404: CountIf[x < 11, B404:G404] + CountIf[x > 29, B404:G404]
A405 = Sequence(Random[1, 6], k, 1, 120)
C405 = CountIf(x ≟ 2, A405)
D405 = CountIf(x ≟ 3, A405)
E405 = CountIf(x ≟ 4, A405)
F405 = CountIf(x ≟ 5, A405)
G405 = CountIf(x ≟ 6, A405)
B405 = CountIf(x ≟ 1, A405)
H405: (B405 - 20)^(2) / 20 + (C405 - 20)^(2) / 20 + (D405 - 20)^(2) / 20 + (E405 - 20)^(2) / 20 + (F405 - 20)^(2) / 20 + (G405 - 20)^(2) / 20
I405 = Sum(abs(B405:G405 - 20))
J405: Max[B405:G405] - Min[B405:G405]
K405 = Max(abs(B405:G405 - 20))
L405: CountIf[x < 11, B405:G405] + CountIf[x > 29, B405:G405]
A406 = Sequence(Random[1, 6], k, 1, 120)
C406 = CountIf(x ≟ 2, A406)
D406 = CountIf(x ≟ 3, A406)
E406 = CountIf(x ≟ 4, A406)
F406 = CountIf(x ≟ 5, A406)
G406 = CountIf(x ≟ 6, A406)
B406 = CountIf(x ≟ 1, A406)
H406: (B406 - 20)^(2) / 20 + (C406 - 20)^(2) / 20 + (D406 - 20)^(2) / 20 + (E406 - 20)^(2) / 20 + (F406 - 20)^(2) / 20 + (G406 - 20)^(2) / 20
I406 = Sum(abs(B406:G406 - 20))
J406: Max[B406:G406] - Min[B406:G406]
K406 = Max(abs(B406:G406 - 20))
L406: CountIf[x < 11, B406:G406] + CountIf[x > 29, B406:G406]
A407 = Sequence(Random[1, 6], k, 1, 120)
C407 = CountIf(x ≟ 2, A407)
D407 = CountIf(x ≟ 3, A407)
E407 = CountIf(x ≟ 4, A407)
F407 = CountIf(x ≟ 5, A407)
G407 = CountIf(x ≟ 6, A407)
B407 = CountIf(x ≟ 1, A407)
H407: (B407 - 20)^(2) / 20 + (C407 - 20)^(2) / 20 + (D407 - 20)^(2) / 20 + (E407 - 20)^(2) / 20 + (F407 - 20)^(2) / 20 + (G407 - 20)^(2) / 20
I407 = Sum(abs(B407:G407 - 20))
J407: Max[B407:G407] - Min[B407:G407]
K407 = Max(abs(B407:G407 - 20))
L407: CountIf[x < 11, B407:G407] + CountIf[x > 29, B407:G407]
A408 = Sequence(Random[1, 6], k, 1, 120)
C408 = CountIf(x ≟ 2, A408)
D408 = CountIf(x ≟ 3, A408)
E408 = CountIf(x ≟ 4, A408)
F408 = CountIf(x ≟ 5, A408)
G408 = CountIf(x ≟ 6, A408)
B408 = CountIf(x ≟ 1, A408)
H408: (B408 - 20)^(2) / 20 + (C408 - 20)^(2) / 20 + (D408 - 20)^(2) / 20 + (E408 - 20)^(2) / 20 + (F408 - 20)^(2) / 20 + (G408 - 20)^(2) / 20
I408 = Sum(abs(B408:G408 - 20))
J408: Max[B408:G408] - Min[B408:G408]
K408 = Max(abs(B408:G408 - 20))
L408: CountIf[x < 11, B408:G408] + CountIf[x > 29, B408:G408]
A409 = Sequence(Random[1, 6], k, 1, 120)
C409 = CountIf(x ≟ 2, A409)
D409 = CountIf(x ≟ 3, A409)
E409 = CountIf(x ≟ 4, A409)
F409 = CountIf(x ≟ 5, A409)
G409 = CountIf(x ≟ 6, A409)
B409 = CountIf(x ≟ 1, A409)
H409: (B409 - 20)^(2) / 20 + (C409 - 20)^(2) / 20 + (D409 - 20)^(2) / 20 + (E409 - 20)^(2) / 20 + (F409 - 20)^(2) / 20 + (G409 - 20)^(2) / 20
I409 = Sum(abs(B409:G409 - 20))
J409: Max[B409:G409] - Min[B409:G409]
K409 = Max(abs(B409:G409 - 20))
L409: CountIf[x < 11, B409:G409] + CountIf[x > 29, B409:G409]
A410 = Sequence(Random[1, 6], k, 1, 120)
C410 = CountIf(x ≟ 2, A410)
D410 = CountIf(x ≟ 3, A410)
E410 = CountIf(x ≟ 4, A410)
F410 = CountIf(x ≟ 5, A410)
G410 = CountIf(x ≟ 6, A410)
B410 = CountIf(x ≟ 1, A410)
H410: (B410 - 20)^(2) / 20 + (C410 - 20)^(2) / 20 + (D410 - 20)^(2) / 20 + (E410 - 20)^(2) / 20 + (F410 - 20)^(2) / 20 + (G410 - 20)^(2) / 20
I410 = Sum(abs(B410:G410 - 20))
J410: Max[B410:G410] - Min[B410:G410]
K410 = Max(abs(B410:G410 - 20))
L410: CountIf[x < 11, B410:G410] + CountIf[x > 29, B410:G410]
A411 = Sequence(Random[1, 6], k, 1, 120)
C411 = CountIf(x ≟ 2, A411)
D411 = CountIf(x ≟ 3, A411)
E411 = CountIf(x ≟ 4, A411)
F411 = CountIf(x ≟ 5, A411)
G411 = CountIf(x ≟ 6, A411)
B411 = CountIf(x ≟ 1, A411)
H411: (B411 - 20)^(2) / 20 + (C411 - 20)^(2) / 20 + (D411 - 20)^(2) / 20 + (E411 - 20)^(2) / 20 + (F411 - 20)^(2) / 20 + (G411 - 20)^(2) / 20
I411 = Sum(abs(B411:G411 - 20))
J411: Max[B411:G411] - Min[B411:G411]
K411 = Max(abs(B411:G411 - 20))
L411: CountIf[x < 11, B411:G411] + CountIf[x > 29, B411:G411]
A412 = Sequence(Random[1, 6], k, 1, 120)
C412 = CountIf(x ≟ 2, A412)
D412 = CountIf(x ≟ 3, A412)
E412 = CountIf(x ≟ 4, A412)
F412 = CountIf(x ≟ 5, A412)
G412 = CountIf(x ≟ 6, A412)
B412 = CountIf(x ≟ 1, A412)
H412: (B412 - 20)^(2) / 20 + (C412 - 20)^(2) / 20 + (D412 - 20)^(2) / 20 + (E412 - 20)^(2) / 20 + (F412 - 20)^(2) / 20 + (G412 - 20)^(2) / 20
I412 = Sum(abs(B412:G412 - 20))
J412: Max[B412:G412] - Min[B412:G412]
K412 = Max(abs(B412:G412 - 20))
L412: CountIf[x < 11, B412:G412] + CountIf[x > 29, B412:G412]
A413 = Sequence(Random[1, 6], k, 1, 120)
C413 = CountIf(x ≟ 2, A413)
D413 = CountIf(x ≟ 3, A413)
E413 = CountIf(x ≟ 4, A413)
F413 = CountIf(x ≟ 5, A413)
G413 = CountIf(x ≟ 6, A413)
B413 = CountIf(x ≟ 1, A413)
H413: (B413 - 20)^(2) / 20 + (C413 - 20)^(2) / 20 + (D413 - 20)^(2) / 20 + (E413 - 20)^(2) / 20 + (F413 - 20)^(2) / 20 + (G413 - 20)^(2) / 20
I413 = Sum(abs(B413:G413 - 20))
J413: Max[B413:G413] - Min[B413:G413]
K413 = Max(abs(B413:G413 - 20))
L413: CountIf[x < 11, B413:G413] + CountIf[x > 29, B413:G413]
A414 = Sequence(Random[1, 6], k, 1, 120)
C414 = CountIf(x ≟ 2, A414)
D414 = CountIf(x ≟ 3, A414)
E414 = CountIf(x ≟ 4, A414)
F414 = CountIf(x ≟ 5, A414)
G414 = CountIf(x ≟ 6, A414)
B414 = CountIf(x ≟ 1, A414)
H414: (B414 - 20)^(2) / 20 + (C414 - 20)^(2) / 20 + (D414 - 20)^(2) / 20 + (E414 - 20)^(2) / 20 + (F414 - 20)^(2) / 20 + (G414 - 20)^(2) / 20
I414 = Sum(abs(B414:G414 - 20))
J414: Max[B414:G414] - Min[B414:G414]
K414 = Max(abs(B414:G414 - 20))
L414: CountIf[x < 11, B414:G414] + CountIf[x > 29, B414:G414]
A415 = Sequence(Random[1, 6], k, 1, 120)
C415 = CountIf(x ≟ 2, A415)
D415 = CountIf(x ≟ 3, A415)
E415 = CountIf(x ≟ 4, A415)
F415 = CountIf(x ≟ 5, A415)
G415 = CountIf(x ≟ 6, A415)
B415 = CountIf(x ≟ 1, A415)
H415: (B415 - 20)^(2) / 20 + (C415 - 20)^(2) / 20 + (D415 - 20)^(2) / 20 + (E415 - 20)^(2) / 20 + (F415 - 20)^(2) / 20 + (G415 - 20)^(2) / 20
I415 = Sum(abs(B415:G415 - 20))
J415: Max[B415:G415] - Min[B415:G415]
K415 = Max(abs(B415:G415 - 20))
L415: CountIf[x < 11, B415:G415] + CountIf[x > 29, B415:G415]
A416 = Sequence(Random[1, 6], k, 1, 120)
C416 = CountIf(x ≟ 2, A416)
D416 = CountIf(x ≟ 3, A416)
E416 = CountIf(x ≟ 4, A416)
F416 = CountIf(x ≟ 5, A416)
G416 = CountIf(x ≟ 6, A416)
B416 = CountIf(x ≟ 1, A416)
H416: (B416 - 20)^(2) / 20 + (C416 - 20)^(2) / 20 + (D416 - 20)^(2) / 20 + (E416 - 20)^(2) / 20 + (F416 - 20)^(2) / 20 + (G416 - 20)^(2) / 20
I416 = Sum(abs(B416:G416 - 20))
J416: Max[B416:G416] - Min[B416:G416]
K416 = Max(abs(B416:G416 - 20))
L416: CountIf[x < 11, B416:G416] + CountIf[x > 29, B416:G416]
A417 = Sequence(Random[1, 6], k, 1, 120)
C417 = CountIf(x ≟ 2, A417)
D417 = CountIf(x ≟ 3, A417)
E417 = CountIf(x ≟ 4, A417)
F417 = CountIf(x ≟ 5, A417)
G417 = CountIf(x ≟ 6, A417)
B417 = CountIf(x ≟ 1, A417)
H417: (B417 - 20)^(2) / 20 + (C417 - 20)^(2) / 20 + (D417 - 20)^(2) / 20 + (E417 - 20)^(2) / 20 + (F417 - 20)^(2) / 20 + (G417 - 20)^(2) / 20
I417 = Sum(abs(B417:G417 - 20))
J417: Max[B417:G417] - Min[B417:G417]
K417 = Max(abs(B417:G417 - 20))
L417: CountIf[x < 11, B417:G417] + CountIf[x > 29, B417:G417]
A418 = Sequence(Random[1, 6], k, 1, 120)
C418 = CountIf(x ≟ 2, A418)
D418 = CountIf(x ≟ 3, A418)
E418 = CountIf(x ≟ 4, A418)
F418 = CountIf(x ≟ 5, A418)
G418 = CountIf(x ≟ 6, A418)
B418 = CountIf(x ≟ 1, A418)
H418: (B418 - 20)^(2) / 20 + (C418 - 20)^(2) / 20 + (D418 - 20)^(2) / 20 + (E418 - 20)^(2) / 20 + (F418 - 20)^(2) / 20 + (G418 - 20)^(2) / 20
I418 = Sum(abs(B418:G418 - 20))
J418: Max[B418:G418] - Min[B418:G418]
K418 = Max(abs(B418:G418 - 20))
L418: CountIf[x < 11, B418:G418] + CountIf[x > 29, B418:G418]
A419 = Sequence(Random[1, 6], k, 1, 120)
C419 = CountIf(x ≟ 2, A419)
D419 = CountIf(x ≟ 3, A419)
E419 = CountIf(x ≟ 4, A419)
F419 = CountIf(x ≟ 5, A419)
G419 = CountIf(x ≟ 6, A419)
B419 = CountIf(x ≟ 1, A419)
H419: (B419 - 20)^(2) / 20 + (C419 - 20)^(2) / 20 + (D419 - 20)^(2) / 20 + (E419 - 20)^(2) / 20 + (F419 - 20)^(2) / 20 + (G419 - 20)^(2) / 20
I419 = Sum(abs(B419:G419 - 20))
J419: Max[B419:G419] - Min[B419:G419]
K419 = Max(abs(B419:G419 - 20))
L419: CountIf[x < 11, B419:G419] + CountIf[x > 29, B419:G419]
A420 = Sequence(Random[1, 6], k, 1, 120)
C420 = CountIf(x ≟ 2, A420)
D420 = CountIf(x ≟ 3, A420)
E420 = CountIf(x ≟ 4, A420)
F420 = CountIf(x ≟ 5, A420)
G420 = CountIf(x ≟ 6, A420)
B420 = CountIf(x ≟ 1, A420)
H420: (B420 - 20)^(2) / 20 + (C420 - 20)^(2) / 20 + (D420 - 20)^(2) / 20 + (E420 - 20)^(2) / 20 + (F420 - 20)^(2) / 20 + (G420 - 20)^(2) / 20
I420 = Sum(abs(B420:G420 - 20))
J420: Max[B420:G420] - Min[B420:G420]
K420 = Max(abs(B420:G420 - 20))
L420: CountIf[x < 11, B420:G420] + CountIf[x > 29, B420:G420]
A421 = Sequence(Random[1, 6], k, 1, 120)
C421 = CountIf(x ≟ 2, A421)
D421 = CountIf(x ≟ 3, A421)
E421 = CountIf(x ≟ 4, A421)
F421 = CountIf(x ≟ 5, A421)
G421 = CountIf(x ≟ 6, A421)
B421 = CountIf(x ≟ 1, A421)
H421: (B421 - 20)^(2) / 20 + (C421 - 20)^(2) / 20 + (D421 - 20)^(2) / 20 + (E421 - 20)^(2) / 20 + (F421 - 20)^(2) / 20 + (G421 - 20)^(2) / 20
I421 = Sum(abs(B421:G421 - 20))
J421: Max[B421:G421] - Min[B421:G421]
K421 = Max(abs(B421:G421 - 20))
L421: CountIf[x < 11, B421:G421] + CountIf[x > 29, B421:G421]
A422 = Sequence(Random[1, 6], k, 1, 120)
C422 = CountIf(x ≟ 2, A422)
D422 = CountIf(x ≟ 3, A422)
E422 = CountIf(x ≟ 4, A422)
F422 = CountIf(x ≟ 5, A422)
G422 = CountIf(x ≟ 6, A422)
B422 = CountIf(x ≟ 1, A422)
H422: (B422 - 20)^(2) / 20 + (C422 - 20)^(2) / 20 + (D422 - 20)^(2) / 20 + (E422 - 20)^(2) / 20 + (F422 - 20)^(2) / 20 + (G422 - 20)^(2) / 20
I422 = Sum(abs(B422:G422 - 20))
J422: Max[B422:G422] - Min[B422:G422]
K422 = Max(abs(B422:G422 - 20))
L422: CountIf[x < 11, B422:G422] + CountIf[x > 29, B422:G422]
A423 = Sequence(Random[1, 6], k, 1, 120)
C423 = CountIf(x ≟ 2, A423)
D423 = CountIf(x ≟ 3, A423)
E423 = CountIf(x ≟ 4, A423)
F423 = CountIf(x ≟ 5, A423)
G423 = CountIf(x ≟ 6, A423)
B423 = CountIf(x ≟ 1, A423)
H423: (B423 - 20)^(2) / 20 + (C423 - 20)^(2) / 20 + (D423 - 20)^(2) / 20 + (E423 - 20)^(2) / 20 + (F423 - 20)^(2) / 20 + (G423 - 20)^(2) / 20
I423 = Sum(abs(B423:G423 - 20))
J423: Max[B423:G423] - Min[B423:G423]
K423 = Max(abs(B423:G423 - 20))
L423: CountIf[x < 11, B423:G423] + CountIf[x > 29, B423:G423]
A424 = Sequence(Random[1, 6], k, 1, 120)
C424 = CountIf(x ≟ 2, A424)
D424 = CountIf(x ≟ 3, A424)
E424 = CountIf(x ≟ 4, A424)
F424 = CountIf(x ≟ 5, A424)
G424 = CountIf(x ≟ 6, A424)
B424 = CountIf(x ≟ 1, A424)
H424: (B424 - 20)^(2) / 20 + (C424 - 20)^(2) / 20 + (D424 - 20)^(2) / 20 + (E424 - 20)^(2) / 20 + (F424 - 20)^(2) / 20 + (G424 - 20)^(2) / 20
I424 = Sum(abs(B424:G424 - 20))
J424: Max[B424:G424] - Min[B424:G424]
K424 = Max(abs(B424:G424 - 20))
L424: CountIf[x < 11, B424:G424] + CountIf[x > 29, B424:G424]
H30: (B30 - 20)^(2) / 20 + (C30 - 20)^(2) / 20 + (D30 - 20)^(2) / 20 + (E30 - 20)^(2) / 20 + (F30 - 20)^(2) / 20 + (G30 - 20)^(2) / 20
H31: (B31 - 20)^(2) / 20 + (C31 - 20)^(2) / 20 + (D31 - 20)^(2) / 20 + (E31 - 20)^(2) / 20 + (F31 - 20)^(2) / 20 + (G31 - 20)^(2) / 20
H32: (B32 - 20)^(2) / 20 + (C32 - 20)^(2) / 20 + (D32 - 20)^(2) / 20 + (E32 - 20)^(2) / 20 + (F32 - 20)^(2) / 20 + (G32 - 20)^(2) / 20
H33: (B33 - 20)^(2) / 20 + (C33 - 20)^(2) / 20 + (D33 - 20)^(2) / 20 + (E33 - 20)^(2) / 20 + (F33 - 20)^(2) / 20 + (G33 - 20)^(2) / 20
H34: (B34 - 20)^(2) / 20 + (C34 - 20)^(2) / 20 + (D34 - 20)^(2) / 20 + (E34 - 20)^(2) / 20 + (F34 - 20)^(2) / 20 + (G34 - 20)^(2) / 20
H35: (B35 - 20)^(2) / 20 + (C35 - 20)^(2) / 20 + (D35 - 20)^(2) / 20 + (E35 - 20)^(2) / 20 + (F35 - 20)^(2) / 20 + (G35 - 20)^(2) / 20
H36: (B36 - 20)^(2) / 20 + (C36 - 20)^(2) / 20 + (D36 - 20)^(2) / 20 + (E36 - 20)^(2) / 20 + (F36 - 20)^(2) / 20 + (G36 - 20)^(2) / 20
H37: (B37 - 20)^(2) / 20 + (C37 - 20)^(2) / 20 + (D37 - 20)^(2) / 20 + (E37 - 20)^(2) / 20 + (F37 - 20)^(2) / 20 + (G37 - 20)^(2) / 20
H38: (B38 - 20)^(2) / 20 + (C38 - 20)^(2) / 20 + (D38 - 20)^(2) / 20 + (E38 - 20)^(2) / 20 + (F38 - 20)^(2) / 20 + (G38 - 20)^(2) / 20
H39: (B39 - 20)^(2) / 20 + (C39 - 20)^(2) / 20 + (D39 - 20)^(2) / 20 + (E39 - 20)^(2) / 20 + (F39 - 20)^(2) / 20 + (G39 - 20)^(2) / 20
H40: (B40 - 20)^(2) / 20 + (C40 - 20)^(2) / 20 + (D40 - 20)^(2) / 20 + (E40 - 20)^(2) / 20 + (F40 - 20)^(2) / 20 + (G40 - 20)^(2) / 20
H41: (B41 - 20)^(2) / 20 + (C41 - 20)^(2) / 20 + (D41 - 20)^(2) / 20 + (E41 - 20)^(2) / 20 + (F41 - 20)^(2) / 20 + (G41 - 20)^(2) / 20
H42: (B42 - 20)^(2) / 20 + (C42 - 20)^(2) / 20 + (D42 - 20)^(2) / 20 + (E42 - 20)^(2) / 20 + (F42 - 20)^(2) / 20 + (G42 - 20)^(2) / 20
H43: (B43 - 20)^(2) / 20 + (C43 - 20)^(2) / 20 + (D43 - 20)^(2) / 20 + (E43 - 20)^(2) / 20 + (F43 - 20)^(2) / 20 + (G43 - 20)^(2) / 20
H44: (B44 - 20)^(2) / 20 + (C44 - 20)^(2) / 20 + (D44 - 20)^(2) / 20 + (E44 - 20)^(2) / 20 + (F44 - 20)^(2) / 20 + (G44 - 20)^(2) / 20
H45: (B45 - 20)^(2) / 20 + (C45 - 20)^(2) / 20 + (D45 - 20)^(2) / 20 + (E45 - 20)^(2) / 20 + (F45 - 20)^(2) / 20 + (G45 - 20)^(2) / 20
H46: (B46 - 20)^(2) / 20 + (C46 - 20)^(2) / 20 + (D46 - 20)^(2) / 20 + (E46 - 20)^(2) / 20 + (F46 - 20)^(2) / 20 + (G46 - 20)^(2) / 20
H47: (B47 - 20)^(2) / 20 + (C47 - 20)^(2) / 20 + (D47 - 20)^(2) / 20 + (E47 - 20)^(2) / 20 + (F47 - 20)^(2) / 20 + (G47 - 20)^(2) / 20
H48: (B48 - 20)^(2) / 20 + (C48 - 20)^(2) / 20 + (D48 - 20)^(2) / 20 + (E48 - 20)^(2) / 20 + (F48 - 20)^(2) / 20 + (G48 - 20)^(2) / 20
H49: (B49 - 20)^(2) / 20 + (C49 - 20)^(2) / 20 + (D49 - 20)^(2) / 20 + (E49 - 20)^(2) / 20 + (F49 - 20)^(2) / 20 + (G49 - 20)^(2) / 20
H50: (B50 - 20)^(2) / 20 + (C50 - 20)^(2) / 20 + (D50 - 20)^(2) / 20 + (E50 - 20)^(2) / 20 + (F50 - 20)^(2) / 20 + (G50 - 20)^(2) / 20
H51: (B51 - 20)^(2) / 20 + (C51 - 20)^(2) / 20 + (D51 - 20)^(2) / 20 + (E51 - 20)^(2) / 20 + (F51 - 20)^(2) / 20 + (G51 - 20)^(2) / 20
H52: (B52 - 20)^(2) / 20 + (C52 - 20)^(2) / 20 + (D52 - 20)^(2) / 20 + (E52 - 20)^(2) / 20 + (F52 - 20)^(2) / 20 + (G52 - 20)^(2) / 20
H53: (B53 - 20)^(2) / 20 + (C53 - 20)^(2) / 20 + (D53 - 20)^(2) / 20 + (E53 - 20)^(2) / 20 + (F53 - 20)^(2) / 20 + (G53 - 20)^(2) / 20
H54: (B54 - 20)^(2) / 20 + (C54 - 20)^(2) / 20 + (D54 - 20)^(2) / 20 + (E54 - 20)^(2) / 20 + (F54 - 20)^(2) / 20 + (G54 - 20)^(2) / 20
H55: (B55 - 20)^(2) / 20 + (C55 - 20)^(2) / 20 + (D55 - 20)^(2) / 20 + (E55 - 20)^(2) / 20 + (F55 - 20)^(2) / 20 + (G55 - 20)^(2) / 20
H56: (B56 - 20)^(2) / 20 + (C56 - 20)^(2) / 20 + (D56 - 20)^(2) / 20 + (E56 - 20)^(2) / 20 + (F56 - 20)^(2) / 20 + (G56 - 20)^(2) / 20
H57: (B57 - 20)^(2) / 20 + (C57 - 20)^(2) / 20 + (D57 - 20)^(2) / 20 + (E57 - 20)^(2) / 20 + (F57 - 20)^(2) / 20 + (G57 - 20)^(2) / 20
J30: Max[B30:G30] - Min[B30:G30]
J31: Max[B31:G31] - Min[B31:G31]
J32: Max[B32:G32] - Min[B32:G32]
J33: Max[B33:G33] - Min[B33:G33]
J34: Max[B34:G34] - Min[B34:G34]
J35: Max[B35:G35] - Min[B35:G35]
J36: Max[B36:G36] - Min[B36:G36]
J37: Max[B37:G37] - Min[B37:G37]
J38: Max[B38:G38] - Min[B38:G38]
J39: Max[B39:G39] - Min[B39:G39]
J40: Max[B40:G40] - Min[B40:G40]
J41: Max[B41:G41] - Min[B41:G41]
J42: Max[B42:G42] - Min[B42:G42]
J43: Max[B43:G43] - Min[B43:G43]
J44: Max[B44:G44] - Min[B44:G44]
J45: Max[B45:G45] - Min[B45:G45]
J46: Max[B46:G46] - Min[B46:G46]
J47: Max[B47:G47] - Min[B47:G47]
J48: Max[B48:G48] - Min[B48:G48]
J49: Max[B49:G49] - Min[B49:G49]
J50: Max[B50:G50] - Min[B50:G50]
J51: Max[B51:G51] - Min[B51:G51]
J52: Max[B52:G52] - Min[B52:G52]
J53: Max[B53:G53] - Min[B53:G53]
J54: Max[B54:G54] - Min[B54:G54]
J55: Max[B55:G55] - Min[B55:G55]
J56: Max[B56:G56] - Min[B56:G56]
J57: Max[B57:G57] - Min[B57:G57]
L30: CountIf[x < 11, B30:G30] + CountIf[x > 29, B30:G30]
L31: CountIf[x < 11, B31:G31] + CountIf[x > 29, B31:G31]
L32: CountIf[x < 11, B32:G32] + CountIf[x > 29, B32:G32]
L33: CountIf[x < 11, B33:G33] + CountIf[x > 29, B33:G33]
L34: CountIf[x < 11, B34:G34] + CountIf[x > 29, B34:G34]
L35: CountIf[x < 11, B35:G35] + CountIf[x > 29, B35:G35]
L36: CountIf[x < 11, B36:G36] + CountIf[x > 29, B36:G36]
L37: CountIf[x < 11, B37:G37] + CountIf[x > 29, B37:G37]
L38: CountIf[x < 11, B38:G38] + CountIf[x > 29, B38:G38]
L39: CountIf[x < 11, B39:G39] + CountIf[x > 29, B39:G39]
L40: CountIf[x < 11, B40:G40] + CountIf[x > 29, B40:G40]
L41: CountIf[x < 11, B41:G41] + CountIf[x > 29, B41:G41]
L42: CountIf[x < 11, B42:G42] + CountIf[x > 29, B42:G42]
L43: CountIf[x < 11, B43:G43] + CountIf[x > 29, B43:G43]
L44: CountIf[x < 11, B44:G44] + CountIf[x > 29, B44:G44]
L45: CountIf[x < 11, B45:G45] + CountIf[x > 29, B45:G45]
L46: CountIf[x < 11, B46:G46] + CountIf[x > 29, B46:G46]
L47: CountIf[x < 11, B47:G47] + CountIf[x > 29, B47:G47]
L48: CountIf[x < 11, B48:G48] + CountIf[x > 29, B48:G48]
L49: CountIf[x < 11, B49:G49] + CountIf[x > 29, B49:G49]
L50: CountIf[x < 11, B50:G50] + CountIf[x > 29, B50:G50]
L51: CountIf[x < 11, B51:G51] + CountIf[x > 29, B51:G51]
L52: CountIf[x < 11, B52:G52] + CountIf[x > 29, B52:G52]
L53: CountIf[x < 11, B53:G53] + CountIf[x > 29, B53:G53]
L54: CountIf[x < 11, B54:G54] + CountIf[x > 29, B54:G54]
L55: CountIf[x < 11, B55:G55] + CountIf[x > 29, B55:G55]
L56: CountIf[x < 11, B56:G56] + CountIf[x > 29, B56:G56]
L57: CountIf[x < 11, B57:G57] + CountIf[x > 29, B57:G57]
H2 = Percentile(H3:H403, 0.95)
I2 = Percentile(I3:I403, 0.950000000000002)
J2 = Percentile(J3:J403, 0.950000000000002)
K2 = Percentile(K3:K403, 0.950000000000002)
L2 = Percentile(L3:L403, 0.950000000000002)
ZähleWenn(x < 11, B33:G33) + ZähleWenn(x > 29, B33:G33): 0
ZähleWenn(x < 11, B34:G34) + ZähleWenn(x > 29, B34:G34): 0
ZähleWenn(x < 11, B35:G35) + ZähleWenn(x > 29, B35:G35): 0
ZähleWenn(x < 11, B36:G36) + ZähleWenn(x > 29, B36:G36): 0
ZähleWenn(x < 11, B37:G37) + ZähleWenn(x > 29, B37:G37): 0
ZähleWenn(x < 11, B38:G38) + ZähleWenn(x > 29, B38:G38): 0
ZähleWenn(x < 11, B39:G39) + ZähleWenn(x > 29, B39:G39): 0
ZähleWenn(x < 11, B40:G40) + ZähleWenn(x > 29, B40:G40): 0
ZähleWenn(x < 11, B41:G41) + ZähleWenn(x > 29, B41:G41): 0
ZähleWenn(x < 11, B42:G42) + ZähleWenn(x > 29, B42:G42): 0
ZähleWenn(x < 11, B43:G43) + ZähleWenn(x > 29, B43:G43): 0
ZähleWenn(x < 11, B44:G44) + ZähleWenn(x > 29, B44:G44): 0
ZähleWenn(x < 11, B45:G45) + ZähleWenn(x > 29, B45:G45): 0
ZähleWenn(x < 11, B46:G46) + ZähleWenn(x > 29, B46:G46): 0
ZähleWenn(x < 11, B47:G47) + ZähleWenn(x > 29, B47:G47): 0
ZähleWenn(x < 11, B48:G48) + ZähleWenn(x > 29, B48:G48): 0
ZähleWenn(x < 11, B49:G49) + ZähleWenn(x > 29, B49:G49): 0
ZähleWenn(x < 11, B50:G50) + ZähleWenn(x > 29, B50:G50): 0
ZähleWenn(x < 11, B51:G51) + ZähleWenn(x > 29, B51:G51): 0
ZähleWenn(x < 11, B52:G52) + ZähleWenn(x > 29, B52:G52): 0
ZähleWenn(x < 11, B53:G53) + ZähleWenn(x > 29, B53:G53): 0
ZähleWenn(x < 11, B54:G54) + ZähleWenn(x > 29, B54:G54): 0
ZähleWenn(x < 11, B55:G55) + ZähleWenn(x > 29, B55:G55): 0
ZähleWenn(x < 11, B56:G56) + ZähleWenn(x > 29, B56:G56): 0
ZähleWenn(x < 11, B57:G57) + ZähleWenn(x > 29, B57:G57): 0
B2: 1
C2: 2
D2: 3
E2: 4
F2: 5
G2: 6
A88 = Sequence(Random[1, 6], k, 1, 120)
C88 = CountIf(x ≟ 2, A88)
D88 = CountIf(x ≟ 3, A88)
E88 = CountIf(x ≟ 4, A88)
F88 = CountIf(x ≟ 5, A88)
G88 = CountIf(x ≟ 6, A88)
B88 = CountIf(x ≟ 1, A88)
H88: (B88 - 20)^(2) / 20 + (C88 - 20)^(2) / 20 + (D88 - 20)^(2) / 20 + (E88 - 20)^(2) / 20 + (F88 - 20)^(2) / 20 + (G88 - 20)^(2) / 20
A122 = Sequence(Random[1, 6], k, 1, 120)
C122 = CountIf(x ≟ 2, A122)
D122 = CountIf(x ≟ 3, A122)
E122 = CountIf(x ≟ 4, A122)
F122 = CountIf(x ≟ 5, A122)
G122 = CountIf(x ≟ 6, A122)
B122 = CountIf(x ≟ 1, A122)
H122: (B122 - 20)^(2) / 20 + (C122 - 20)^(2) / 20 + (D122 - 20)^(2) / 20 + (E122 - 20)^(2) / 20 + (F122 - 20)^(2) / 20 + (G122 - 20)^(2) / 20
A262 = Sequence(Random[1, 6], k, 1, 120)
C262 = CountIf(x ≟ 2, A262)
D262 = CountIf(x ≟ 3, A262)
E262 = CountIf(x ≟ 4, A262)
F262 = CountIf(x ≟ 5, A262)
G262 = CountIf(x ≟ 6, A262)
B262 = CountIf(x ≟ 1, A262)
H262: (B262 - 20)^(2) / 20 + (C262 - 20)^(2) / 20 + (D262 - 20)^(2) / 20 + (E262 - 20)^(2) / 20 + (F262 - 20)^(2) / 20 + (G262 - 20)^(2) / 20
A375 = Sequence(Random[1, 6], k, 1, 120)
C375 = CountIf(x ≟ 2, A375)
D375 = CountIf(x ≟ 3, A375)
E375 = CountIf(x ≟ 4, A375)
F375 = CountIf(x ≟ 5, A375)
G375 = CountIf(x ≟ 6, A375)
B375 = CountIf(x ≟ 1, A375)
H375: (B375 - 20)^(2) / 20 + (C375 - 20)^(2) / 20 + (D375 - 20)^(2) / 20 + (E375 - 20)^(2) / 20 + (F375 - 20)^(2) / 20 + (G375 - 20)^(2) / 20
a = true