-- CHECKS A CASE STATEMENT OF SIZE 256

with Instrument;
use Instrument;
procedure Casea2 is
    Test_Array : array (0 .. 10) of Boolean;
    Bool_Result : Boolean;
    J : Integer;
    -- THIS FUNCTION RETURNS TWO TIMES T
    function Caser (T : in Integer) return Integer is
        X : Integer;
    begin
        case T is
            when 0 =>
                X := T + 0;
            when 1 =>
                X := T + 1;
            when 2 =>
                X := T + 2;
            when 3 =>
                X := T + 3;
            when 4 =>
                X := T + 4;
            when 5 =>
                X := T + 5;
            when 6 =>
                X := T + 6;
            when 7 =>
                X := T + 7;
            when 8 =>
                X := T + 8;
            when 9 =>
                X := T + 9;
            when 10 =>
                X := T + 10;
            when 11 =>
                X := T + 11;
            when 12 =>
                X := T + 12;
            when 13 =>
                X := T + 13;
            when 14 =>
                X := T + 14;
            when 15 =>
                X := T + 15;
            when 16 =>
                X := T + 16;
            when 17 =>
                X := T + 17;
            when 18 =>
                X := T + 18;
            when 19 =>
                X := T + 19;
            when 20 =>
                X := T + 20;
            when 21 =>
                X := T + 21;
            when 22 =>
                X := T + 22;
            when 23 =>
                X := T + 23;
            when 24 =>
                X := T + 24;
            when 25 =>
                X := T + 25;
            when 26 =>
                X := T + 26;
            when 27 =>
                X := T + 27;
            when 28 =>
                X := T + 28;
            when 29 =>
                X := T + 29;
            when 30 =>
                X := T + 30;
            when 31 =>
                X := T + 31;
            when 32 =>
                X := T + 32;
            when 33 =>
                X := T + 33;
            when 34 =>
                X := T + 34;
            when 35 =>
                X := T + 35;
            when 36 =>
                X := T + 36;
            when 37 =>
                X := T + 37;
            when 38 =>
                X := T + 38;
            when 39 =>
                X := T + 39;
            when 40 =>
                X := T + 40;
            when 41 =>
                X := T + 41;
            when 42 =>
                X := T + 42;
            when 43 =>
                X := T + 43;
            when 44 =>
                X := T + 44;
            when 45 =>
                X := T + 45;
            when 46 =>
                X := T + 46;
            when 47 =>
                X := T + 47;
            when 48 =>
                X := T + 48;
            when 49 =>
                X := T + 49;
            when 50 =>
                X := T + 50;
            when 51 =>
                X := T + 51;
            when 52 =>
                X := T + 52;
            when 53 =>
                X := T + 53;
            when 54 =>
                X := T + 54;
            when 55 =>
                X := T + 55;
            when 56 =>
                X := T + 56;
            when 57 =>
                X := T + 57;
            when 58 =>
                X := T + 58;
            when 59 =>
                X := T + 59;
            when 60 =>
                X := T + 60;
            when 61 =>
                X := T + 61;
            when 62 =>
                X := T + 62;
            when 63 =>
                X := T + 63;
            when 64 =>
                X := T + 64;
            when 65 =>
                X := T + 65;
            when 66 =>
                X := T + 66;
            when 67 =>
                X := T + 67;
            when 68 =>
                X := T + 68;
            when 69 =>
                X := T + 69;
            when 70 =>
                X := T + 70;
            when 71 =>
                X := T + 71;
            when 72 =>
                X := T + 72;
            when 73 =>
                X := T + 73;
            when 74 =>
                X := T + 74;
            when 75 =>
                X := T + 75;
            when 76 =>
                X := T + 76;
            when 77 =>
                X := T + 77;
            when 78 =>
                X := T + 78;
            when 79 =>
                X := T + 79;
            when 80 =>
                X := T + 80;
            when 81 =>
                X := T + 81;
            when 82 =>
                X := T + 82;
            when 83 =>
                X := T + 83;
            when 84 =>
                X := T + 84;
            when 85 =>
                X := T + 85;
            when 86 =>
                X := T + 86;
            when 87 =>
                X := T + 87;
            when 88 =>
                X := T + 88;
            when 89 =>
                X := T + 89;
            when 90 =>
                X := T + 90;
            when 91 =>
                X := T + 91;
            when 92 =>
                X := T + 92;
            when 93 =>
                X := T + 93;
            when 94 =>
                X := T + 94;
            when 95 =>
                X := T + 95;
            when 96 =>
                X := T + 96;
            when 97 =>
                X := T + 97;
            when 98 =>
                X := T + 98;
            when 99 =>
                X := T + 99;
            when 100 =>
                X := T + 100;
            when 101 =>
                X := T + 101;
            when 102 =>
                X := T + 102;
            when 103 =>
                X := T + 103;
            when 104 =>
                X := T + 104;
            when 105 =>
                X := T + 105;
            when 106 =>
                X := T + 106;
            when 107 =>
                X := T + 107;
            when 108 =>
                X := T + 108;
            when 109 =>
                X := T + 109;
            when 110 =>
                X := T + 110;
            when 111 =>
                X := T + 111;
            when 112 =>
                X := T + 112;
            when 113 =>
                X := T + 113;
            when 114 =>
                X := T + 114;
            when 115 =>
                X := T + 115;
            when 116 =>
                X := T + 116;
            when 117 =>
                X := T + 117;
            when 118 =>
                X := T + 118;
            when 119 =>
                X := T + 119;
            when 120 =>
                X := T + 120;
            when 121 =>
                X := T + 121;
            when 122 =>
                X := T + 122;
            when 123 =>
                X := T + 123;
            when 124 =>
                X := T + 124;
            when 125 =>
                X := T + 125;
            when 126 =>
                X := T + 126;
            when 127 =>
                X := T + 127;
            when 128 =>
                X := T + 128;
            when 129 =>
                X := T + 129;
            when 130 =>
                X := T + 130;
            when 131 =>
                X := T + 131;
            when 132 =>
                X := T + 132;
            when 133 =>
                X := T + 133;
            when 134 =>
                X := T + 134;
            when 135 =>
                X := T + 135;
            when 136 =>
                X := T + 136;
            when 137 =>
                X := T + 137;
            when 138 =>
                X := T + 138;
            when 139 =>
                X := T + 139;
            when 140 =>
                X := T + 140;
            when 141 =>
                X := T + 141;
            when 142 =>
                X := T + 142;
            when 143 =>
                X := T + 143;
            when 144 =>
                X := T + 144;
            when 145 =>
                X := T + 145;
            when 146 =>
                X := T + 146;
            when 147 =>
                X := T + 147;
            when 148 =>
                X := T + 148;
            when 149 =>
                X := T + 149;
            when 150 =>
                X := T + 150;
            when 151 =>
                X := T + 151;
            when 152 =>
                X := T + 152;
            when 153 =>
                X := T + 153;
            when 154 =>
                X := T + 154;
            when 155 =>
                X := T + 155;
            when 156 =>
                X := T + 156;
            when 157 =>
                X := T + 157;
            when 158 =>
                X := T + 158;
            when 159 =>
                X := T + 159;
            when 160 =>
                X := T + 160;
            when 161 =>
                X := T + 161;
            when 162 =>
                X := T + 162;
            when 163 =>
                X := T + 163;
            when 164 =>
                X := T + 164;
            when 165 =>
                X := T + 165;
            when 166 =>
                X := T + 166;
            when 167 =>
                X := T + 167;
            when 168 =>
                X := T + 168;
            when 169 =>
                X := T + 169;
            when 170 =>
                X := T + 170;
            when 171 =>
                X := T + 171;
            when 172 =>
                X := T + 172;
            when 173 =>
                X := T + 173;
            when 174 =>
                X := T + 174;
            when 175 =>
                X := T + 175;
            when 176 =>
                X := T + 176;
            when 177 =>
                X := T + 177;
            when 178 =>
                X := T + 178;
            when 179 =>
                X := T + 179;
            when 180 =>
                X := T + 180;
            when 181 =>
                X := T + 181;
            when 182 =>
                X := T + 182;
            when 183 =>
                X := T + 183;
            when 184 =>
                X := T + 184;
            when 185 =>
                X := T + 185;
            when 186 =>
                X := T + 186;
            when 187 =>
                X := T + 187;
            when 188 =>
                X := T + 188;
            when 189 =>
                X := T + 189;
            when 190 =>
                X := T + 190;
            when 191 =>
                X := T + 191;
            when 192 =>
                X := T + 192;
            when 193 =>
                X := T + 193;
            when 194 =>
                X := T + 194;
            when 195 =>
                X := T + 195;
            when 196 =>
                X := T + 196;
            when 197 =>
                X := T + 197;
            when 198 =>
                X := T + 198;
            when 199 =>
                X := T + 199;
            when 200 =>
                X := T + 200;
            when 201 =>
                X := T + 201;
            when 202 =>
                X := T + 202;
            when 203 =>
                X := T + 203;
            when 204 =>
                X := T + 204;
            when 205 =>
                X := T + 205;
            when 206 =>
                X := T + 206;
            when 207 =>
                X := T + 207;
            when 208 =>
                X := T + 208;
            when 209 =>
                X := T + 209;
            when 210 =>
                X := T + 210;
            when 211 =>
                X := T + 211;
            when 212 =>
                X := T + 212;
            when 213 =>
                X := T + 213;
            when 214 =>
                X := T + 214;
            when 215 =>
                X := T + 215;
            when 216 =>
                X := T + 216;
            when 217 =>
                X := T + 217;
            when 218 =>
                X := T + 218;
            when 219 =>
                X := T + 219;
            when 220 =>
                X := T + 220;
            when 221 =>
                X := T + 221;
            when 222 =>
                X := T + 222;
            when 223 =>
                X := T + 223;
            when 224 =>
                X := T + 224;
            when 225 =>
                X := T + 225;
            when 226 =>
                X := T + 226;
            when 227 =>
                X := T + 227;
            when 228 =>
                X := T + 228;
            when 229 =>
                X := T + 229;
            when 230 =>
                X := T + 230;
            when 231 =>
                X := T + 231;
            when 232 =>
                X := T + 232;
            when 233 =>
                X := T + 233;
            when 234 =>
                X := T + 234;
            when 235 =>
                X := T + 235;
            when 236 =>
                X := T + 236;
            when 237 =>
                X := T + 237;
            when 238 =>
                X := T + 238;
            when 239 =>
                X := T + 239;
            when 240 =>
                X := T + 240;
            when 241 =>
                X := T + 241;
            when 242 =>
                X := T + 242;
            when 243 =>
                X := T + 243;
            when 244 =>
                X := T + 244;
            when 245 =>
                X := T + 245;
            when 246 =>
                X := T + 246;
            when 247 =>
                X := T + 247;
            when 248 =>
                X := T + 248;
            when 249 =>
                X := T + 249;
            when 250 =>
                X := T + 250;
            when 251 =>
                X := T + 251;
            when 252 =>
                X := T + 252;
            when 253 =>
                X := T + 253;
            when 254 =>
                X := T + 254;
            when 255 =>
                X := T + 255;
            when others =>
                X := 99;
        end case;

        return X;

    end Caser;
begin
    Start ("CASEA2", "CHECKS A CASE STATEMENT OF SIZE 256");
    -- INITIALIZE THE ARRAY
    for I in 1 .. 1000 loop
        for I in 0 .. 10 loop
            Test_Array (I) := False;
        end loop;

        -- CHECK OUR CASE STATEMENT

        for I in 0 .. 10 loop
            if (Caser (10 * I) = 20 * I) then
                Test_Array (I) := True;
            end if;
        end loop;

        -- FIND OUT IF THEY ALL WORKED
        Bool_Result := True;
        for I in 0 .. 10 loop
            Bool_Result := Bool_Result and Test_Array (I);
        end loop;

        if not Bool_Result then
            Comment ("FAILED");

        end if;
    end loop;
    Stop;
end Casea2;