exploit the possibilities
Home Files News &[SERVICES_TAB]About Contact Add New

mux256.vhd

mux256.vhd
Posted Dec 21, 1999

mux256.vhd

tags | encryption
SHA-256 | 8c6494840ea62823076dbe5e80693f4ea60e4e7179edc25db2d12546935ec84b

mux256.vhd

Change Mirror Download
---------|---------|---------|---------|---------|---------|---------|---------|
-- Author : Tom Vu
-- Date : 09/07/97
-- Description : Search Unit, 24 search units per ASIC
--------------------------------------------------------------------------------
library ieee;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
--------------------------------------------------------------------------------
entity MUX256 is

port(

SHIFT_OUT : in std_logic_vector(7 downto 0);
PT_VECTOR : in std_logic_vector(255 downto 0);
BIT_MUX : out std_logic
);


end MUX256;

--------------------------------------------------------------------------------
architecture beh of MUX256 is
--------------------------------------------------------------------------------


begin
--------------------------------------------------------------------------------
DECODER_PR: process(SHIFT_OUT,PT_VECTOR)
--------------------------------------------------------------------------------
variable ii : integer;
begin
ii := conv_integer(SHIFT_OUT);
case ii is
when 0 => BIT_MUX <= PT_VECTOR(0);
when 1 => BIT_MUX <= PT_VECTOR(1);
when 2 => BIT_MUX <= PT_VECTOR(2);
when 3 => BIT_MUX <= PT_VECTOR(3);

when 4 => BIT_MUX <= PT_VECTOR(4);
when 5 => BIT_MUX <= PT_VECTOR(5);
when 6 => BIT_MUX <= PT_VECTOR(6);
when 7 => BIT_MUX <= PT_VECTOR(7);

when 8 => BIT_MUX <= PT_VECTOR(8);
when 9 => BIT_MUX <= PT_VECTOR(9);
when 10 => BIT_MUX <= PT_VECTOR(10);
when 11 => BIT_MUX <= PT_VECTOR(11);

when 12 => BIT_MUX <= PT_VECTOR(12);
when 13 => BIT_MUX <= PT_VECTOR(13);
when 14 => BIT_MUX <= PT_VECTOR(14);
when 15 => BIT_MUX <= PT_VECTOR(15);

when 16 => BIT_MUX <= PT_VECTOR(16);
when 17 => BIT_MUX <= PT_VECTOR(17);
when 18 => BIT_MUX <= PT_VECTOR(18);
when 19 => BIT_MUX <= PT_VECTOR(19);

when 20 => BIT_MUX <= PT_VECTOR(20);
when 21 => BIT_MUX <= PT_VECTOR(21);
when 22 => BIT_MUX <= PT_VECTOR(22);
when 23 => BIT_MUX <= PT_VECTOR(23);

when 24 => BIT_MUX <= PT_VECTOR(24);
when 25 => BIT_MUX <= PT_VECTOR(25);
when 26 => BIT_MUX <= PT_VECTOR(26);
when 27 => BIT_MUX <= PT_VECTOR(27);

when 28 => BIT_MUX <= PT_VECTOR(28);
when 29 => BIT_MUX <= PT_VECTOR(29);
when 30 => BIT_MUX <= PT_VECTOR(30);
when 31 => BIT_MUX <= PT_VECTOR(31);
when 32 => BIT_MUX <= PT_VECTOR(32);
when 33 => BIT_MUX <= PT_VECTOR(33);
when 34 => BIT_MUX <= PT_VECTOR(34);
when 35 => BIT_MUX <= PT_VECTOR(35);
when 36 => BIT_MUX <= PT_VECTOR(36);
when 37 => BIT_MUX <= PT_VECTOR(37);
when 38 => BIT_MUX <= PT_VECTOR(38);
when 39 => BIT_MUX <= PT_VECTOR(39);
when 40 => BIT_MUX <= PT_VECTOR(40);
when 41 => BIT_MUX <= PT_VECTOR(41);
when 42 => BIT_MUX <= PT_VECTOR(42);
when 43 => BIT_MUX <= PT_VECTOR(43);
when 44 => BIT_MUX <= PT_VECTOR(44);
when 45 => BIT_MUX <= PT_VECTOR(45);
when 46 => BIT_MUX <= PT_VECTOR(46);
when 47 => BIT_MUX <= PT_VECTOR(47);
when 48 => BIT_MUX <= PT_VECTOR(48);
when 49 => BIT_MUX <= PT_VECTOR(49);
when 50 => BIT_MUX <= PT_VECTOR(50);
when 51 => BIT_MUX <= PT_VECTOR(51);
when 52 => BIT_MUX <= PT_VECTOR(52);
when 53 => BIT_MUX <= PT_VECTOR(53);
when 54 => BIT_MUX <= PT_VECTOR(54);
when 55 => BIT_MUX <= PT_VECTOR(55);
when 56 => BIT_MUX <= PT_VECTOR(56);
when 57 => BIT_MUX <= PT_VECTOR(57);
when 58 => BIT_MUX <= PT_VECTOR(58);
when 59 => BIT_MUX <= PT_VECTOR(59);
when 60 => BIT_MUX <= PT_VECTOR(60);
when 61 => BIT_MUX <= PT_VECTOR(61);
when 62 => BIT_MUX <= PT_VECTOR(62);
when 63 => BIT_MUX <= PT_VECTOR(63);
when 64 => BIT_MUX <= PT_VECTOR(64);
when 65 => BIT_MUX <= PT_VECTOR(65);
when 66 => BIT_MUX <= PT_VECTOR(66);
when 67 => BIT_MUX <= PT_VECTOR(67);
when 68 => BIT_MUX <= PT_VECTOR(68);
when 69 => BIT_MUX <= PT_VECTOR(69);
when 70 => BIT_MUX <= PT_VECTOR(70);
when 71 => BIT_MUX <= PT_VECTOR(71);
when 72 => BIT_MUX <= PT_VECTOR(72);
when 73 => BIT_MUX <= PT_VECTOR(73);
when 74 => BIT_MUX <= PT_VECTOR(74);
when 75 => BIT_MUX <= PT_VECTOR(75);
when 76 => BIT_MUX <= PT_VECTOR(76);
when 77 => BIT_MUX <= PT_VECTOR(77);
when 78 => BIT_MUX <= PT_VECTOR(78);
when 79 => BIT_MUX <= PT_VECTOR(79);
when 80 => BIT_MUX <= PT_VECTOR(80);
when 81 => BIT_MUX <= PT_VECTOR(81);
when 82 => BIT_MUX <= PT_VECTOR(82);
when 83 => BIT_MUX <= PT_VECTOR(83);
when 84 => BIT_MUX <= PT_VECTOR(84);
when 85 => BIT_MUX <= PT_VECTOR(85);
when 86 => BIT_MUX <= PT_VECTOR(86);
when 87 => BIT_MUX <= PT_VECTOR(87);
when 88 => BIT_MUX <= PT_VECTOR(88);
when 89 => BIT_MUX <= PT_VECTOR(89);
when 90 => BIT_MUX <= PT_VECTOR(90);
when 91 => BIT_MUX <= PT_VECTOR(91);
when 92 => BIT_MUX <= PT_VECTOR(92);
when 93 => BIT_MUX <= PT_VECTOR(93);
when 94 => BIT_MUX <= PT_VECTOR(94);
when 95 => BIT_MUX <= PT_VECTOR(95);
when 96 => BIT_MUX <= PT_VECTOR(96);
when 97 => BIT_MUX <= PT_VECTOR(97);
when 98 => BIT_MUX <= PT_VECTOR(98);
when 99 => BIT_MUX <= PT_VECTOR(99);

when 100 => BIT_MUX <= PT_VECTOR(100);
when 101 => BIT_MUX <= PT_VECTOR(101);
when 102 => BIT_MUX <= PT_VECTOR(102);
when 103 => BIT_MUX <= PT_VECTOR(103);
when 104 => BIT_MUX <= PT_VECTOR(104);
when 105 => BIT_MUX <= PT_VECTOR(105);
when 106 => BIT_MUX <= PT_VECTOR(106);
when 107 => BIT_MUX <= PT_VECTOR(107);
when 108 => BIT_MUX <= PT_VECTOR(108);
when 109 => BIT_MUX <= PT_VECTOR(109);
when 110 => BIT_MUX <= PT_VECTOR(110);
when 111 => BIT_MUX <= PT_VECTOR(111);
when 112 => BIT_MUX <= PT_VECTOR(112);
when 113 => BIT_MUX <= PT_VECTOR(113);
when 114 => BIT_MUX <= PT_VECTOR(114);
when 115 => BIT_MUX <= PT_VECTOR(115);
when 116 => BIT_MUX <= PT_VECTOR(116);
when 117 => BIT_MUX <= PT_VECTOR(117);
when 118 => BIT_MUX <= PT_VECTOR(118);
when 119 => BIT_MUX <= PT_VECTOR(119);
when 120 => BIT_MUX <= PT_VECTOR(120);
when 121 => BIT_MUX <= PT_VECTOR(121);
when 122 => BIT_MUX <= PT_VECTOR(122);
when 123 => BIT_MUX <= PT_VECTOR(123);
when 124 => BIT_MUX <= PT_VECTOR(124);
when 125 => BIT_MUX <= PT_VECTOR(125);
when 126 => BIT_MUX <= PT_VECTOR(126);
when 127 => BIT_MUX <= PT_VECTOR(127);
when 128 => BIT_MUX <= PT_VECTOR(128);
when 129 => BIT_MUX <= PT_VECTOR(129);
when 130 => BIT_MUX <= PT_VECTOR(130);
when 131 => BIT_MUX <= PT_VECTOR(131);
when 132 => BIT_MUX <= PT_VECTOR(132);
when 133 => BIT_MUX <= PT_VECTOR(133);
when 134 => BIT_MUX <= PT_VECTOR(134);
when 135 => BIT_MUX <= PT_VECTOR(135);
when 136 => BIT_MUX <= PT_VECTOR(136);
when 137 => BIT_MUX <= PT_VECTOR(137);
when 138 => BIT_MUX <= PT_VECTOR(138);
when 139 => BIT_MUX <= PT_VECTOR(139);
when 140 => BIT_MUX <= PT_VECTOR(140);
when 141 => BIT_MUX <= PT_VECTOR(141);
when 142 => BIT_MUX <= PT_VECTOR(142);
when 143 => BIT_MUX <= PT_VECTOR(143);
when 144 => BIT_MUX <= PT_VECTOR(144);
when 145 => BIT_MUX <= PT_VECTOR(145);
when 146 => BIT_MUX <= PT_VECTOR(146);
when 147 => BIT_MUX <= PT_VECTOR(147);
when 148 => BIT_MUX <= PT_VECTOR(148);
when 149 => BIT_MUX <= PT_VECTOR(149);
when 150 => BIT_MUX <= PT_VECTOR(150);
when 151 => BIT_MUX <= PT_VECTOR(151);
when 152 => BIT_MUX <= PT_VECTOR(152);
when 153 => BIT_MUX <= PT_VECTOR(153);
when 154 => BIT_MUX <= PT_VECTOR(154);
when 155 => BIT_MUX <= PT_VECTOR(155);
when 156 => BIT_MUX <= PT_VECTOR(156);
when 157 => BIT_MUX <= PT_VECTOR(157);
when 158 => BIT_MUX <= PT_VECTOR(158);
when 159 => BIT_MUX <= PT_VECTOR(159);
when 160 => BIT_MUX <= PT_VECTOR(160);
when 161 => BIT_MUX <= PT_VECTOR(161);
when 162 => BIT_MUX <= PT_VECTOR(162);
when 163 => BIT_MUX <= PT_VECTOR(163);
when 164 => BIT_MUX <= PT_VECTOR(164);
when 165 => BIT_MUX <= PT_VECTOR(165);
when 166 => BIT_MUX <= PT_VECTOR(166);
when 167 => BIT_MUX <= PT_VECTOR(167);
when 168 => BIT_MUX <= PT_VECTOR(168);
when 169 => BIT_MUX <= PT_VECTOR(169);
when 170 => BIT_MUX <= PT_VECTOR(170);
when 171 => BIT_MUX <= PT_VECTOR(171);
when 172 => BIT_MUX <= PT_VECTOR(172);
when 173 => BIT_MUX <= PT_VECTOR(173);
when 174 => BIT_MUX <= PT_VECTOR(174);
when 175 => BIT_MUX <= PT_VECTOR(175);
when 176 => BIT_MUX <= PT_VECTOR(176);
when 177 => BIT_MUX <= PT_VECTOR(177);
when 178 => BIT_MUX <= PT_VECTOR(178);
when 179 => BIT_MUX <= PT_VECTOR(179);
when 180 => BIT_MUX <= PT_VECTOR(180);
when 181 => BIT_MUX <= PT_VECTOR(181);
when 182 => BIT_MUX <= PT_VECTOR(182);
when 183 => BIT_MUX <= PT_VECTOR(183);
when 184 => BIT_MUX <= PT_VECTOR(184);
when 185 => BIT_MUX <= PT_VECTOR(185);
when 186 => BIT_MUX <= PT_VECTOR(186);
when 187 => BIT_MUX <= PT_VECTOR(187);
when 188 => BIT_MUX <= PT_VECTOR(188);
when 189 => BIT_MUX <= PT_VECTOR(189);
when 190 => BIT_MUX <= PT_VECTOR(190);
when 191 => BIT_MUX <= PT_VECTOR(191);
when 192 => BIT_MUX <= PT_VECTOR(192);
when 193 => BIT_MUX <= PT_VECTOR(193);
when 194 => BIT_MUX <= PT_VECTOR(194);
when 195 => BIT_MUX <= PT_VECTOR(195);
when 196 => BIT_MUX <= PT_VECTOR(196);
when 197 => BIT_MUX <= PT_VECTOR(197);
when 198 => BIT_MUX <= PT_VECTOR(198);
when 199 => BIT_MUX <= PT_VECTOR(199);

when 200 => BIT_MUX <= PT_VECTOR(200);
when 201 => BIT_MUX <= PT_VECTOR(201);
when 202 => BIT_MUX <= PT_VECTOR(202);
when 203 => BIT_MUX <= PT_VECTOR(203);
when 204 => BIT_MUX <= PT_VECTOR(204);
when 205 => BIT_MUX <= PT_VECTOR(205);
when 206 => BIT_MUX <= PT_VECTOR(206);
when 207 => BIT_MUX <= PT_VECTOR(207);
when 208 => BIT_MUX <= PT_VECTOR(208);
when 209 => BIT_MUX <= PT_VECTOR(209);
when 210 => BIT_MUX <= PT_VECTOR(210);
when 211 => BIT_MUX <= PT_VECTOR(211);
when 212 => BIT_MUX <= PT_VECTOR(212);
when 213 => BIT_MUX <= PT_VECTOR(213);
when 214 => BIT_MUX <= PT_VECTOR(214);
when 215 => BIT_MUX <= PT_VECTOR(215);
when 216 => BIT_MUX <= PT_VECTOR(216);
when 217 => BIT_MUX <= PT_VECTOR(217);
when 218 => BIT_MUX <= PT_VECTOR(218);
when 219 => BIT_MUX <= PT_VECTOR(219);
when 220 => BIT_MUX <= PT_VECTOR(220);
when 221 => BIT_MUX <= PT_VECTOR(221);
when 222 => BIT_MUX <= PT_VECTOR(222);
when 223 => BIT_MUX <= PT_VECTOR(223);
when 224 => BIT_MUX <= PT_VECTOR(224);
when 225 => BIT_MUX <= PT_VECTOR(225);
when 226 => BIT_MUX <= PT_VECTOR(226);
when 227 => BIT_MUX <= PT_VECTOR(227);
when 228 => BIT_MUX <= PT_VECTOR(228);
when 229 => BIT_MUX <= PT_VECTOR(229);
when 230 => BIT_MUX <= PT_VECTOR(230);
when 231 => BIT_MUX <= PT_VECTOR(231);
when 232 => BIT_MUX <= PT_VECTOR(232);
when 233 => BIT_MUX <= PT_VECTOR(233);
when 234 => BIT_MUX <= PT_VECTOR(234);
when 235 => BIT_MUX <= PT_VECTOR(235);
when 236 => BIT_MUX <= PT_VECTOR(236);
when 237 => BIT_MUX <= PT_VECTOR(237);
when 238 => BIT_MUX <= PT_VECTOR(238);
when 239 => BIT_MUX <= PT_VECTOR(239);
when 240 => BIT_MUX <= PT_VECTOR(240);
when 241 => BIT_MUX <= PT_VECTOR(241);
when 242 => BIT_MUX <= PT_VECTOR(242);
when 243 => BIT_MUX <= PT_VECTOR(243);
when 244 => BIT_MUX <= PT_VECTOR(244);
when 245 => BIT_MUX <= PT_VECTOR(245);
when 246 => BIT_MUX <= PT_VECTOR(246);
when 247 => BIT_MUX <= PT_VECTOR(247);
when 248 => BIT_MUX <= PT_VECTOR(248);
when 249 => BIT_MUX <= PT_VECTOR(249);
when 250 => BIT_MUX <= PT_VECTOR(250);
when 251 => BIT_MUX <= PT_VECTOR(251);
when 252 => BIT_MUX <= PT_VECTOR(252);
when 253 => BIT_MUX <= PT_VECTOR(253);
when 254 => BIT_MUX <= PT_VECTOR(254);
when 255 => BIT_MUX <= PT_VECTOR(255);

when others => BIT_MUX <= '0';
end case;

end process DECODER_PR;

--------------------------------------------------------------------------------
end beh;
--------------------------------------------------------------------------------

Login or Register to add favorites

File Archive:

March 2024

  • Su
  • Mo
  • Tu
  • We
  • Th
  • Fr
  • Sa
  • 1
    Mar 1st
    16 Files
  • 2
    Mar 2nd
    0 Files
  • 3
    Mar 3rd
    0 Files
  • 4
    Mar 4th
    32 Files
  • 5
    Mar 5th
    28 Files
  • 6
    Mar 6th
    42 Files
  • 7
    Mar 7th
    17 Files
  • 8
    Mar 8th
    13 Files
  • 9
    Mar 9th
    0 Files
  • 10
    Mar 10th
    0 Files
  • 11
    Mar 11th
    15 Files
  • 12
    Mar 12th
    19 Files
  • 13
    Mar 13th
    21 Files
  • 14
    Mar 14th
    38 Files
  • 15
    Mar 15th
    15 Files
  • 16
    Mar 16th
    0 Files
  • 17
    Mar 17th
    0 Files
  • 18
    Mar 18th
    10 Files
  • 19
    Mar 19th
    32 Files
  • 20
    Mar 20th
    46 Files
  • 21
    Mar 21st
    16 Files
  • 22
    Mar 22nd
    13 Files
  • 23
    Mar 23rd
    0 Files
  • 24
    Mar 24th
    0 Files
  • 25
    Mar 25th
    12 Files
  • 26
    Mar 26th
    31 Files
  • 27
    Mar 27th
    19 Files
  • 28
    Mar 28th
    0 Files
  • 29
    Mar 29th
    0 Files
  • 30
    Mar 30th
    0 Files
  • 31
    Mar 31st
    0 Files

Top Authors In Last 30 Days

File Tags

Systems

packet storm

© 2022 Packet Storm. All rights reserved.

Services
Security Services
Hosting By
Rokasec
close